timmy 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ab3e84bce8d95e5a76d488fb1abb5f8505c6c90a
-  data.tar.gz: 10ccacef3de073ba665185003850a0e83c4334e3
+  metadata.gz: 9d197122524ccb2e1140f5cce09773a107679bfe
+  data.tar.gz: 463efa752c2bb2d56b33aa2886e792e9156f2ffd
 SHA512:
-  metadata.gz: 26175e0bf819a6f13c5b9f29f28159c130865463837727ab23beb6d0d1e40f5101e5623025458719d3065a151a1f4f96c8f5c44b43ec53a686f1e2eb2d04550c
-  data.tar.gz: d0e2ee57f092eea87d35ea718cdc76704568cc09b89e443cfd79b3cfb5589d33816ae7099c913bf2da298bbe739a433c796b69a2145f386b520e82c3e673534d
+  metadata.gz: b036c9c0a24faedfbf0407cb51b6353e60413115cc191922aa76f6cfeb3edb36727fee3be628920fd2124f970baf307c3f3b0dc575d12a113a239e9c8f59ce82
+  data.tar.gz: 96a35e620a984c902c18c317baca1890db96a6aa76bd53524aa8fbc7d3c44a590c016d42c27aa118974abed18033b5a783bc03fcb419ae673992d59c08edd473

data/bin/timmy

@@ -3,32 +3,4 @@
 require 'optparse'
 require 'timmy'
 
-options = {
-  replay: nil,
-  profile: false
-}
-
-OptionParser.new do |parser|
-  parser.banner = "Usage: [COMMAND] | timmy"
-  parser.separator ""
-  parser.separator "Options:"
-  parser.on("-r LOG", "--replay LOG", "Replay specific log file") do |replay|
-    options[:replay] = replay
-  end
-  parser.on("-p", "--profile", "Profile targeted timers ") do |profile|
-    options[:profile] = profile
-  end
-end.parse!
-
-Timmy::ConfigLoader.load
-Timmy::Logger.clear
-
-if replay = options[:replay]
-  Timmy::Runner.replay_log(replay)
-else
-  Timmy::Runner.consume_stdin
-end
-
-if options[:profile]
-  Timmy::TargetedTimer.put_stopped_profiles
-end
+Timmy::Runner.run

data/lib/timmy/logger.rb

@@ -1,10 +1,6 @@
 module Timmy
   class Logger
     class << self
-      def clear
-        @output = ''
-      end
-
       def set_output_directory(dir)
         @output_directory = dir
       end
@@ -13,23 +9,57 @@ module Timmy
         @precision = precision
       end
 
-      def put(line, internal: false, since: 0)
-        duration = format_duration(MasterTimer.get - since)
-        if internal
-          @output += "#{duration} > #{line}\n"
-          puts bold("#{duration} #{line}")
-        else
-          @output += "#{duration} | #{line}\n"
-          puts feint(duration) + " " + line
+      def put_output(output)
+        duration = MasterTimer.get
+        formatted_duration = format_duration(duration)
+
+        puts feint(formatted_duration) + " " + output
+
+        @output ||= ''
+        @output += sprintf("%.9f %s\n", duration, output)
+      end
+
+      def put_timer(timer)
+        puts format_timer(timer)
+      end
+
+      def put_stopped_profiles
+        puts "Slowest targeted timers:"
+
+        slowest_timers = TargetedTimerManager
+          .stopped
+          .sort_by { |timer| -timer.duration }
+          .slice(0, 10)
+
+        slowest_timers.each do |timer|
+          put_timer(timer)
         end
+
+        puts
       end
 
       def finalize
-        suffix = "#{MasterTimer.start.to_i}+#{(MasterTimer.get).to_i}"
+        suffix = "#{MasterTimer.start.to_i}+#{MasterTimer.get.to_i}"
         filename = File.join(output_directory, "timmy-#{suffix}.log")
 
-        put("EOF > #{filename}", internal: true)
         File.write(filename, @output)
+
+        puts feint("Log written to #{filename}")
+        puts
+      end
+
+      private
+
+      def format_timer(timer)
+        string = "#{bold(format_duration(timer.duration))} #{format_id(timer.definition.id)}"
+        string += " (#{timer.group})" if timer.group
+        string += ": #{green(timer.label)}" if timer.label
+
+        string
+      end
+
+      def format_id(id)
+        id.to_s
       end
 
       def format_duration(duration)
@@ -37,7 +67,9 @@ module Timmy
         sprintf(format, duration / 60, duration % 60)
       end
 
-      private
+      def green(string)
+        "\e[0m\e[32m#{string}\e[0m"
+      end
 
       def bold(string)
         "\e[0m\e[1m#{string}\e[0m"

data/lib/timmy/master_timer.rb

@@ -1,18 +1,19 @@
 module Timmy
   class MasterTimer
     class << self
-      def start(time = nil)
-        @start_time = time if time
+      def start(frozen_time = nil)
+        @start_time = frozen_time if frozen_time
         @start_time ||= Time.now.to_f
       end
 
       def get
-        return @duration if @duration
+        return @frozen_duration if @frozen_duration
+
         Time.now.to_f - @start_time
       end
 
-      def set(duration)
-        @duration = duration
+      def set(frozen_duration)
+        @frozen_duration = frozen_duration
       end
     end
   end

data/lib/timmy/option_parser.rb

@@ -0,0 +1,54 @@
+module Timmy
+  class OptionParser
+    class << self
+      def parse
+        options = {
+          replay: nil,
+          profile: false,
+          logger_output_directory: nil,
+          logger_precision: nil
+        }
+
+        ::OptionParser.new do |parser|
+          parser.banner = <<-EOS
+\e[1mtimmy\e[0m -- time execution of commands and their stages based on console output
+
+\e[33mUsage:\e[0m
+
+Pipe output from arbitrary command:
+
+    \e[36m[COMMAND] | timmy [OPTIONS]\e[0m
+
+Run without a pipe (usually with --replay):
+
+    \e[36mtimmy [OPTIONS]\e[0m
+EOS
+
+          parser.separator ""
+          parser.separator "\e[33mOptions:\e[0m"
+          parser.separator ""
+
+          parser.on("-r LOG", "--replay LOG", "Replay specific log file") do |replay|
+            options[:replay] = replay
+          end
+
+          parser.on("-p", "--profile", "Profile targeted timers") do |profile|
+            options[:profile] = profile
+          end
+
+          parser.on("--logger-output-dir DIR", "Save logs to different directory (default: \"/tmp\")") do |logger_output_directory|
+            options[:logger_output_directory] = logger_output_directory
+          end
+
+          parser.on("--logger-precision NUM", Integer, "Set precision used when printing time (default: 0)") do |logger_precision|
+            options[:logger_precision] = logger_precision
+          end
+
+          parser.separator ""
+        end.parse!
+
+        options
+      end
+    end
+  end
+end

data/lib/timmy/runner.rb

@@ -1,45 +1,73 @@
 module Timmy
   class Runner
     class << self
-      def consume_stdin
-        MasterTimer.start
+      def run
+        ConfigLoader.load
 
-        STDIN.each_line do |line|
-          run_line(line.rstrip)
-        end
+        options = OptionParser.parse
 
-        TargetedTimer.stop_all
-        Logger.finalize
-      end
+        if value = options[:logger_output_directory]
+          Logger.set_output_directory(value)
+        end
 
-      def replay_log(log)
-        basename = File.basename(log)
-        match = log.match(/timmy-(?<time>\d+)\+\d+.log/)
-        time = match[:time].to_i
+        if value = options[:logger_precision]
+          Logger.set_precision(value)
+        end
 
-        MasterTimer.start(time)
+        if replay = options[:replay]
+          replay_log(replay)
+        else
+          consume_stdin
+        end
 
-        lines = File.readlines(log)
-        lines.each do |line|
-          if match = line.match(/^(?<m>\d+):(?<s>\d+(\.\d+)?) \| (?<content>.*)/)
-            content = match[:content]
-            time = match[:m].to_i * 60 + match[:s].to_f
+        if options[:profile]
+          Logger.put_stopped_profiles
+        end
+      end
 
-            MasterTimer.set(time)
-            run_line(content)
+      def consume_stdin
+        around_run_lines do
+          STDIN.each_line do |line|
+            run_line(line.rstrip)
           end
+          Logger.put_output("EOF")
         end
+      end
 
-        TargetedTimer.stop_all
-        Logger.finalize
+      def replay_log(log)
+        around_run_lines do
+          start_time = File.basename(log).match(/timmy-(?<time>\d+)\+\d+.log/)[:time].to_i
+          MasterTimer.start(start_time)
+
+          File.readlines(log).each do |line|
+            if match = line.match(/^(?<m>\d+):(?<s>\d+(\.\d+)?) \| (?<content>.*)/)
+              line_time = match[:m].to_i * 60 + match[:s].to_f
+              MasterTimer.set(line_time)
+              run_line(match[:content])
+            elsif match = line.match(/^(?<s>\d+(\.\d+)?) (?<content>.*)/)
+              line_time = match[:s].to_f
+              MasterTimer.set(line_time)
+              run_line(match[:content])
+            end
+          end
+        end
       end
 
       private
 
+      def around_run_lines
+        MasterTimer.start
+
+        yield
+
+        TargetedTimerManager.stop_all
+        Logger.finalize
+      end
+
       def run_line(line)
-        TargetedTimer.start_for_line(line)
-        Logger.put(line)
-        TargetedTimer.stop_for_line(line)
+        TargetedTimerManager.start_for_line(line)
+        Logger.put_output(line)
+        TargetedTimerManager.stop_for_line(line)
       end
     end
   end

data/lib/timmy/targeted_timer.rb

@@ -1,85 +1,16 @@
 module Timmy
   class TargetedTimer
-    class << self
-      def start_for_line(line)
-        TargetedTimerDefinition.all.each do |definition|
-          if match = line.match(definition.start_regex)
-            stop_by_id(definition.id)
-            label = match.send(:[], :label) rescue nil
-            started.push(self.new(definition, label: label))
-          end
-        end
-      end
+    attr_reader :definition, :label, :group, :start_time, :duration
 
-      def stop_for_line(line)
-        started.each do |timer|
-          if (stop_regex = timer.definition.stop_regex) && line.match?(stop_regex)
-            stop(timer)
-          end
-        end
-      end
-
-      def stop(timer)
-        timer.stop
-        started.delete(timer)
-        stopped.push(timer)
-      end
-
-      def stop_by_id(id)
-        matches = started.select { |timer| timer.definition.id == id }
-        matches.each { |timer| stop(timer) }
-      end
-
-      def stop_all
-        started.each { |timer| stop(timer) }
-      end
-
-      def started
-        @started ||= []
-      end
-
-      def stopped
-        @stopped ||= []
-      end
-
-      def put_stopped_profiles
-        puts ""
-        puts "Slowest targeted timers:"
-        TargetedTimer.stopped.sort_by { |timer| -timer.duration }[0..9].each do |timer|
-          timer.put_profile
-        end
-      end
-    end
-
-    attr_reader :definition, :label, :duration
-
-    def initialize(definition, label: nil)
+    def initialize(definition, label: nil, group: nil)
       @definition = definition
-      @start_time = MasterTimer.get
       @label = label
+      @group = group
+      @start_time = MasterTimer.get
     end
 
     def stop
-      put
       @duration = MasterTimer.get - @start_time
     end
-
-    def put_profile
-      duration = Logger.format_duration(@duration)
-      puts " - #{duration} - #{formatted_id} - #{@label}"
-    end
-
-    private
-
-    def put
-      log_line = formatted_id
-      log_line += " #{@label}" if @label
-
-      Logger.put(log_line, since: @start_time, internal: true)
-    end
-
-    def formatted_id
-      @definition.id.to_s.split('_').collect(&:capitalize).join
-    end
   end
 end

data/lib/timmy/targeted_timer_definition.rb

@@ -2,9 +2,14 @@ module Timmy
   class TargetedTimerDefinition
     class << self
       def add(id, start_regex:, stop_regex: nil)
+        delete(id)
         all.push(self.new(id, start_regex: start_regex, stop_regex: stop_regex))
       end
 
+      def delete(id)
+        all.reject! { |definition| definition.id == id }
+      end
+
       def all
         @all ||= [
           self.new(:docker_build,

data/lib/timmy/targeted_timer_manager.rb

@@ -0,0 +1,63 @@
+module Timmy
+  class TargetedTimerManager
+    class << self
+      def start_for_line(line)
+        TargetedTimerDefinition.all.each do |definition|
+          if match = line.match(definition.start_regex)
+            label = get_capture(match, :label)
+            group = get_capture(match, :group)
+
+            stop_by_id_and_group(definition.id, group)
+            started.push(TargetedTimer.new(definition, label: label, group: group))
+          end
+        end
+      end
+
+      def stop_for_line(line)
+        started.each do |timer|
+          if (stop_regex = timer.definition.stop_regex) &&
+             (match = line.match(stop_regex)) &&
+             get_capture(match, :group) == timer.group
+            stop(timer)
+          end
+        end
+      end
+
+      def stop(timer)
+        timer.stop
+        Logger.put_timer(timer)
+
+        started.delete(timer)
+        stopped.push(timer)
+      end
+
+      def stop_by_id_and_group(id, group)
+        matches = started
+          .select { |timer| timer.definition.id }
+          .select { |timer| timer.group == group }
+
+        matches.each { |timer| stop(timer) }
+      end
+
+      def stop_all
+        started.each { |timer| stop(timer) }
+      end
+
+      def started
+        @started ||= []
+      end
+
+      def stopped
+        @stopped ||= []
+      end
+
+      private
+
+      def get_capture(match, name)
+        match[name]
+      rescue IndexError
+        nil
+      end
+    end
+  end
+end

data/lib/timmy/version.rb

@@ -1,3 +1,3 @@
 module Timmy
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/timmy.rb

@@ -1,7 +1,9 @@
 require "timmy/config_loader"
 require "timmy/logger"
 require "timmy/master_timer"
+require "timmy/option_parser"
 require "timmy/runner"
 require "timmy/targeted_timer"
 require "timmy/targeted_timer_definition"
+require "timmy/targeted_timer_manager"
 require "timmy/version"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: timmy
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Karol Słuszniak
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-29 00:00:00.000000000 Z
+date: 2019-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -67,9 +67,11 @@ files:
 - lib/timmy/config_loader.rb
 - lib/timmy/logger.rb
 - lib/timmy/master_timer.rb
+- lib/timmy/option_parser.rb
 - lib/timmy/runner.rb
 - lib/timmy/targeted_timer.rb
 - lib/timmy/targeted_timer_definition.rb
+- lib/timmy/targeted_timer_manager.rb
 - lib/timmy/version.rb
 homepage: https://github.com/karolsluszniak/timmy
 licenses: