card-mod-logger 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 793c6146f566d8d475adf699b82d26b431b86863582496d4d6aa210f783ca9fc
+  data.tar.gz: eafa632be5a94ac5bb412a5a4718627312ec0078b93b0196e2cea8653b398505
+SHA512:
+  metadata.gz: ddbfd0418cd943d08251886fa7d4b1762cfdde179c6d6c32859fcc68e2d9e35d14228774e7a8938482b074e5c57f2e065f89b16ef46ecd0c9dd661b3154a39a4
+  data.tar.gz: e2220d262c28e4b5bab39e60e73d9d9e8113cf63b8147eed6d6c48ec5667535bb3117194b77c4fb7654e35632f5f025a2b0a59ea7c79dc8070a734c54138f274

data/README.md

@@ -0,0 +1,64 @@
+<!--
+# @title README - mod: logger
+-->
+
+# Logger mod (experimental)
+
+This experimental mod has code in support of decko-friendly performance and request 
+logging. It cannot boast the sophistication or support of modern logging tools, but
+there is enough clever code here to keep it around and hope that it some day may be
+useful, if for nothing else than for building richer integration with more established
+logging tools.
+
+## Performance logger
+
+To enable logging add a performance_logger hash to your configuration.
+
+Example:
+
+```
+ config.performance_logger = {
+   min_time: 100,                 # show only method calls that are slower than 100ms
+   max_depth: 3,                  # show nested method calls only up to depth 3
+   details: true,                 # show method arguments and sql
+   methods: [:event, :search, :fetch, :view],  # choose methods to log
+   log_level: :info
+ }
+```
+
+ If you give :methods a hash you can log arbitrary methods. The syntax is as follows:
+   class =>  method type => method name => log options
+
+```
+ Example:
+   Card => {
+     instance: [:fetch, :search],
+     singleton: { fetch: { :title => 'Card.fetch' } },
+     all: {
+       fetch{
+         message: 2,           # use second argument passed to fetch
+         details: :to_s,       # use return value of to_s in method context
+         title: proc { |method_context| method_context.name }
+       },
+     },
+   }
+```
+
+`class`, `method type` and `log options` are optional.
+
+Default values are `Card`, `:all`, and 
+```
+  { title: method name, message: first argument, details: remaining arguments }
+```
+
+For example `[:fetch]` is equivalent to 
+```
+  Card => { all: { fetch: { message: 1, details: 1..-1 } }
+```
+
+## Request Logger
+
+To use the request logger, set `config.paths[request_log]` to the path you
+want to log to, eg 'log/request.log'.
+
+It should then begin producing a csv output.

data/lib/cardio/logger/performance/big_brother.rb

@@ -0,0 +1,88 @@
+module Cardio
+  class Logger
+    class Performance
+      module BigBrother
+        def watch_method method_name, method_type=:all, options={}
+          Performance.enable_method method_name
+          if !SPECIAL_METHODS.include? method_name
+            if method_type == :all || method_type == :singleton
+              add_singleton_logging method_name, options
+            end
+            if method_type == :all || method_type == :instance
+              add_instance_logging method_name, options
+            end
+          end
+        end
+
+        def watch_instance_method *names
+          names.each do |name|
+            watch_method name, :instance
+          end
+        end
+
+        def watch_singleton_method *names
+          names.each do |name|
+            watch_method name, :singleton
+          end
+        end
+
+        def watch_all_instance_methods
+          watch_instance_method *instance_methods
+        end
+
+        def watch_all_singleton_methods
+          fragile_methods = [:default_scope, :default_scopes, :default_scopes=]  # if I touch these methods ActiveRecord breaks
+          watch_singleton_method *(singleton_methods - fragile_methods)
+        end
+
+        def watch_all_methods
+          watch_all_instance_methods
+          watch_all_singleton_methods
+        end
+
+        private
+
+        def add_singleton_logging method_name, options
+          return unless singleton_class.method_defined? method_name
+          m = method(method_name)
+          add_logging method_name, :define_singleton_method, options do |bind_object, args, &block|
+            m.call(*args, &block)
+          end
+        end
+
+        def add_instance_logging  method_name, options
+          return unless method_defined? method_name
+          m = instance_method(method_name)
+          add_logging method_name, :define_method, options do  |bind_object, args, &block|
+            m.bind(bind_object).(*args, &block)
+          end
+        end
+
+        def add_logging method_name, define_method, options, &bind_block
+          send(define_method, method_name) do |*args, &block|
+            #puts "#{method name } logged"
+            Rails.logger.error "#{method_name} logged"
+            log_args = {}
+            options.each do |key,value|
+              log_args[key] = case value
+                              when Integer then args[value-1]
+                              when Range   then args[value]
+                              when Symbol  then eval(value.to_s)
+                              when Proc    then value.call(self)
+                              else              value
+                              end
+            end
+            Performance.with_timer(method_name, log_args) do
+              bind_block.call(self, args, &block)
+            end
+          end
+        end
+
+        def log_options_variable_name method_name, define_method
+          "@_#{self.class.name}_#{method_name.hash.to_s.sub(/^-/,'_')}_#{define_method}_logging_options".to_sym
+        end
+      end
+    end
+  end
+end
+

data/lib/cardio/logger/performance/category_log.rb

@@ -0,0 +1,80 @@
+module Cardio
+  class Logger
+    class Performance
+      class CategoryLog
+        HIERARCHY = {
+          'SQL'  => 0,
+          'rule' => 1,
+          'fetch' => 2,
+          'content' => 3,
+          'format'  => 4
+        }
+
+        def initialize category=nil
+          @time_per_category = Hash.new { |h, key| h[key] = 0 }
+          @start_time = {}
+          @stack = []
+          if category
+            start category
+          end
+        end
+
+        def start category
+          if active_category
+            if hierarchy(category) < hierarchy(active_category)
+              pause active_category
+            else
+              return
+            end
+          end
+          @start_time[category] = Time.now
+          @stack << category
+
+        end
+
+        def stop category
+          if active_category == category
+            save_duration category
+            @stack.pop
+            if active_category
+              continue active_category
+            end
+          end
+        end
+
+        def duration category
+          @time_per_category[category]
+        end
+
+        def each_pair
+          cats = (['SQL', 'rule', 'fetch', 'content', 'format'] & @time_per_category.keys) |  @time_per_category.keys
+          cats.each do |key|
+            yield(key, @time_per_category[key])
+          end
+        end
+
+        private
+
+        def active_category
+          @stack.last
+        end
+
+        def pause category
+          save_duration category
+        end
+
+        def continue category
+          @start_time[category] = Time.now
+        end
+
+        def hierarchy category
+          HIERARCHY[category] || -1
+        end
+
+        def save_duration category
+          @time_per_category[category] += (Time.now - @start_time[category]) * 1000
+        end
+      end
+    end
+  end
+end

data/lib/cardio/logger/performance/entry.rb

@@ -0,0 +1,129 @@
+module Cardio
+  class Logger
+    class Performance
+      class Entry
+        attr_accessor :level, :valid, :context, :parent, :children_cnt, :duration, :children
+        attr_reader :message, :category, :category_duration, :details
+
+        def initialize( parent, level, args )
+          @start = Time.new
+          start_category_timer
+          @message = "#{ args[:title] ||  args[:method] || '' }"
+          @message += ": #{ args[:message] }" if args[:message]
+          @details = args[:details]
+          @context = args[:context]
+          @category = args[:category]
+
+          @level = level
+          @duration = nil
+          @valid = true
+          @parent = parent
+          @children_cnt = 0
+          @children = []
+          if @parent
+            @parent.add_children self
+            #@sibling_nr = @parent.children_cnt
+          end
+        end
+
+        def add_children child=false
+          @children_cnt += 1
+          @children << child if child
+        end
+
+        def delete_children child=false
+          @children_cnt -= 1
+          @children.delete child if child
+
+        end
+
+        def has_younger_siblings?
+          @parent && @parent.children_cnt > 0 #@sibling_nr
+        end
+
+        def start_category_timer
+          @category_duration = 0
+          @category_start = Time.now
+        end
+
+        def pause_category_timer
+          save_category_duration
+        end
+
+        def save_category_duration
+          if @category
+            @category_duration += (Time.now - @category_start) * 1000
+          end
+        end
+
+        def continue_category_timer
+          if @category
+            @category_start = Time.now
+          end
+        end
+
+        def save_duration
+          save_category_duration
+          @duration = (Time.now - @start) * 1000
+        end
+
+        def delete
+          @valid = false
+          @parent.delete_children(self) if @parent
+        end
+
+
+        # deletes the children counts in order to print the tree;
+        # must be called in the right order
+        #
+        # More robuts but more expensive approach: use @sibling_nr instead of counting @children_cnt down,
+        # but @sibling_nr has to be updated for all siblings of an entry if the entry gets deleted due to
+        # min_time or max_depth restrictions in the config, so we have to save all children relations for that
+        def to_s!
+          @to_s ||= begin
+            msg = indent
+            msg += "(%d.2ms) " % @duration if @duration
+            msg += @message if @message
+
+            if @details
+              msg +=  ", " + @details.to_s.gsub( "\n", "\n#{ indent(false) }#{' '* TAB_SIZE}" )
+            end
+            @parent.delete_children if @parent
+            msg
+          end
+        end
+
+        private
+
+        def indent link=true
+          @indent ||= begin
+            if @level == 0
+              "\n"
+            else
+              res = '  '
+              res += (1..level-1).inject('') do |msg, index|
+                if younger_siblings[index]
+                  msg <<  '|' + ' ' * (TAB_SIZE-1)
+                else
+                  msg << ' ' * TAB_SIZE
+                end
+              end
+
+              res += link ? '|--' : '  '
+            end
+          end
+        end
+
+        def younger_siblings
+          res = []
+          next_parent = self
+          while (next_parent)
+            res << next_parent.has_younger_siblings?
+            next_parent = next_parent.parent
+          end
+          res.reverse
+        end
+      end
+    end
+  end
+end

data/lib/cardio/logger/performance/html_formatter.rb

@@ -0,0 +1,108 @@
+module Cardio
+  class Logger
+    class Performance
+      class HtmlFormatter
+        def initialize performance_logger
+          @log = performance_logger.log
+          @category_log = performance_logger.category_log
+        end
+
+        def output
+          @output ||=
+            begin
+              list =
+                @log.inject([]) do |tree, entry|
+                  if !entry.parent && entry.message != 'fetch: performance_log'
+                    tree << entry
+                  end
+                  tree
+                end
+              list_to_accordion list
+            end
+        end
+
+        private
+
+        def list_to_accordion list
+          list.map do |entry|
+            if entry.children && entry.children.present?
+              accordion_entry entry
+            else
+              simple_entry entry
+            end
+          end.join "\n"
+        end
+
+
+        def duration_badge duration
+          if duration
+            <<-HTML
+              <span class='badge #{"badge-danger" if duration > 100} open-slow-items'> #{"%d.2ms" % duration}
+              </span>
+            HTML
+          end
+        end
+
+
+        def panel_heading entry, collapse_id
+          <<-HTML
+            <h4 class="panel-title">
+              <a data-toggle="collapse" data-parent="#accordion-#{collapse_id}" href="##{collapse_id}" aria-expanded="true" aria-controls="#{collapse_id}" class="show-fast-items">
+                <span title='#{entry.details}'>
+                  #{entry.message}
+                </span>
+              </a>
+              #{ duration_badge entry.duration}
+            </h4>
+            #{ extra_info entry }
+          HTML
+        end
+
+        def extra_info entry
+          if entry == @log.first
+            cat_sum = ''
+            @category_log.each_pair do |category, time|
+              cat_sum << "<strong>%s:</strong> %d.2ms  " % [category, time]
+            end
+            <<-HTML
+              #{cat_sum}
+              <span class="float-right">
+                <a class="toggle-fast-items">hide < 100ms</a>
+              </span>
+            HTML
+          end
+        end
+
+        def simple_entry entry
+          <<-HTML
+            <li class='list-group-item  #{ entry.duration > 100 ? 'panel-danger' : 'duration-ok'}'>
+              <span title='#{entry.details}'>
+                #{ entry.message }
+              </span>
+              #{ duration_badge entry.duration}
+            </li>
+          HTML
+        end
+
+        def accordion_entry entry
+          panel_body = list_to_accordion entry.children
+          collapse_id = entry.hash.to_s
+          %{
+            <div class="panel-group" id="accordion-#{collapse_id}" role="tablist" aria-multiselectable="true">
+              <div class="panel panel-default #{ entry.duration > 100 ? 'panel-danger' : 'duration-ok'}">
+                <div class="panel-heading" role="tab" id="heading-#{collapse_id}">
+                  #{ panel_heading entry, collapse_id }
+                </div>
+                <div id="#{collapse_id}" class="panel-collapse collapse" role="tabpanel" aria-labelledby="heading-#{collapse_id}">
+                  <div class="panel-body">
+                    #{ panel_body }
+                  </div>
+                </div>
+              </div>
+            </div>
+            }
+        end
+      end
+    end
+  end
+end

data/lib/cardio/logger/performance/text_formatter.rb

@@ -0,0 +1,37 @@
+module Cardio
+  class Logger
+    class Performance
+      class TextFormatter
+        def initialize performance_logger
+          @log = performance_logger.log
+          @category_log = performance_logger.category_log
+        end
+
+        def output
+          @output ||= "#{details}\n#{category_summary}\n"
+        end
+
+        def details
+          @details ||=
+            @log.select { |entry| entry.valid }.map do |entry|
+              entry.to_s!
+            end.join "\n"
+        end
+
+        def category_summary
+          @category_summary ||=
+            begin
+              total = 0
+              output = ''
+              @category_log.each_pair do |category, time|
+                total += time
+                output << "%s: %d.2ms\n" % [category, time]
+              end
+              output << "total: %d.2ms" % total
+              output
+            end
+        end
+      end
+    end
+  end
+end

data/lib/cardio/logger/performance.rb

@@ -0,0 +1,285 @@
+module Cardio
+  class Logger
+    class Performance
+      DEFAULT_CLASS = Card
+      DEFAULT_METHOD_TYPE = :all
+      DEFAULT_LOG_LEVEL = :info
+      DEFAULT_METHOD_OPTIONS = {
+        :title => :method_name,
+        :message => 1,
+        :details => 1..-1,
+        :context => nil
+      }
+
+      SPECIAL_METHODS = [:search, :view, :event, :rule, :execute] # these methods have already a Decko.with_logging block
+      # we don't have to monkey patch them, only turn the logging on with adding the symbol to the methods hash
+
+      TAB_SIZE = 3
+      cattr_reader :log, :category_log
+
+      @@log = []
+      @@category_log = CategoryLog.new
+      @@context_entries = []
+      @@active_entries = []
+      @@current_level = 0
+
+      class << self
+        def default_methods_config
+          [:execute, :rule, :fetch, :view]
+#         {
+#           # ActiveRecord => {
+#           #   :instance => {
+#           #     :save      => { :category => 'SQL'},
+#           #     :take => { :category => 'SQL'},
+#           #     :_create_record => { :category => 'SQL'},
+#           #     :_update_record => { :category => 'SQL'}
+#           #   },
+#           #   :singleton=> {
+#           #     :delete    => { :category => 'SQL'},
+#           #     :find    => { :category => 'SQL'},
+#           #     :update    => { :category => 'SQL'},
+#           #     :create    => { :category => 'SQL'},
+#           #     :where    => { :category => 'SQL'}
+#           #   }
+#           # },
+#           Card => {
+#             :instance => {
+#               :rule_card => { :category => 'rule' }
+#               # :'update!' => { :category => 'SQL'},
+#               # :update    => { :category => 'SQL'},
+#               # :save      => { :category => 'SQL'},
+#               # :'save!'   => { :category => 'SQL'},
+#               # :delete    => { :category => 'SQL'},
+#               # :'delete!' => { :category => 'SQL'}
+#             },
+#             :singleton => {
+#               :fetch => { :category => 'fetch' },
+#               :view  => { :category => 'content'},
+#               # :delete => { :category => 'SQL'},
+#               # :find => { :category => 'SQL'},
+#               # :update => { :category => 'SQL'},
+#               # :create => { :category => 'SQL'},
+#               :where   => { :category => 'SQL'},
+#               :execute => { :category => 'SQL'}
+# #              :take   => { :category => 'Take'}
+#             }
+#           },
+#           # Card::Query => {
+#           #   :instance => {
+#           #     :run_sql => { :category => 'SQL'},
+#           #
+#           #   }
+#           # }
+#         }
+        end
+
+        def load_config args
+          args = params_to_config args
+          @details = args[:details] || false
+          @max_depth = args[:max_depth] || false
+          @min_time = args[:min_time] || false
+          @log_level = args[:log_level] || DEFAULT_LOG_LEVEL
+          @output = args[:output] || :text
+          @output_card = args[:output_card] || '*all'
+          @enabled_methods = ::Set.new
+          if args[:methods] == :default
+            args[:methods] = default_methods_config
+          end
+          prepare_methods_for_logging args[:methods] if args[:methods]
+        end
+
+        def start args = {}
+          @@current_level = 0
+          @@log = []
+          @@context_entries = []
+          @@active_entries = []
+          @@first_entry = new_entry(args)
+          @@category_log = CategoryLog.new args[:category]
+        end
+
+        def stop
+          finish_all_context_entries
+          if @@first_entry
+            @@first_entry.save_duration
+            finish_entry @@first_entry
+          end
+          print_log
+        end
+
+
+        def with_timer method, args, &block
+          if args[:context]
+            update_context args[:context]
+          end
+
+          timer = new_entry args.merge(:method => method)
+          begin
+            result = block.call
+          ensure
+            timer.save_duration
+            finish_entry timer
+            finish_context
+          end
+          result
+        end
+
+        def enable_method method_name
+          @enabled_methods ||= ::Set.new
+          @enabled_methods << method_name
+        end
+
+        def enabled_method? method_name
+          @enabled_methods && @enabled_methods.include?(method_name)
+        end
+
+        private
+
+        def update_context new_context
+          # if the current context was created by an entry on the same level
+          # then finish it if it's a different context
+          if (current_context = @@context_entries.last) &&
+            current_context.level + 1 == @@current_level && # the
+            new_context != current_context.context
+            finish_entry @@context_entries.pop
+          end
+
+          # start new context if it's different from the current context
+          if @@context_entries.empty? || new_context != @@context_entries.last.context
+            @@context_entries << new_entry(:title => 'process', :message => new_context, :context => new_context)
+          end
+        end
+
+        def finish_context
+          # finish all deeper nested contexts
+          while @@context_entries.last && @@context_entries.last.level >= @@current_level
+            finish_entry @@context_entries.pop
+          end
+          # we don't know whether the next entry will belong to the same context or will start a new one
+          # so we save the time
+          @@context_entries.last.save_duration if @@context_entries.last
+        end
+
+        def print_log
+          if @output == :card && @output_card
+            html_log = HtmlFormatter.new(self).output
+            card = @output_card.fetch :performance_log, new: { type: :pointer }
+            card.add_log_entry @@log.first.message, html_log
+          elsif @output == :html
+            HtmlFormatter.new(self).output
+          else
+            text_log = TextFormatter.new(self).output
+            Rails.logger.send @log_level, text_log
+          end
+        end
+
+
+        def new_entry args
+          args.delete(:details) unless @details
+          level = @@current_level
+
+          last_entry = @@active_entries.last
+          parent =
+            if last_entry
+              last_entry.level == level ? last_entry.parent : last_entry
+            end
+
+          if args[:category]
+            @@category_log.start args[:category]
+          end
+
+          @@log << Entry.new(parent, level, args)
+          @@current_level += 1
+          @@active_entries << @@log.last
+
+          @@log.last
+        end
+
+        def finish_entry entry
+          if entry.category
+            @@category_log.stop entry.category
+          end
+          if (@max_depth && entry.level > @max_depth) || (@min_time && entry.duration < @min_time)
+            entry.delete
+          end
+          @@active_entries.pop
+          @@current_level -= 1
+        end
+
+        def finish_all_context_entries
+          while (entry = @@context_entries.pop) do
+            entry.save_duration unless entry.duration
+            finish_entry entry
+          end
+        end
+
+        def prepare_methods_for_logging args
+          classes = hashify_and_verify_keys(args, DEFAULT_CLASS) do |key|
+            key.kind_of?(Class) || key.kind_of?(Module)
+          end
+
+          classes.each do |klass, method_types|
+            klass.extend BigBrother # add watch methods
+
+            method_types = hashify_and_verify_keys(method_types, DEFAULT_METHOD_TYPE) do |key|
+              [:all, :instance, :singleton].include? key
+            end
+
+            method_types.each do |method_type, methods|
+              methods = hashify_and_verify_keys methods
+              methods.each do |method_name, options|
+                klass.watch_method method_name, method_type, DEFAULT_METHOD_OPTIONS.merge(options)
+              end
+            end
+
+          end
+        end
+
+        def hashify_and_verify_keys args, default_key = nil
+          if default_key
+            case args
+            when Symbol
+              { default_key => [args] }
+            when Array
+              { default_key => args }
+            when Hash
+              if block_given?
+                args.keys.select {|key| !(yield(key))}.each do |key|
+                  args[default_key] = { key => args[key] }
+                  args.delete key
+                end
+              end
+              args
+            end
+          else
+            case args
+            when Symbol
+              { args => {} }
+            when Array
+              args.inject({}) do |h, key|
+                h[key] = {}
+                h
+              end
+            else
+              args
+            end
+          end
+        end
+
+        def params_to_config args
+          args[:details] = args[:details] == 'true' ? true : false
+          args[:max_depth] &&= args[:max_depth].to_i
+          args[:min_time] &&= args[:min_time].to_i
+          args[:output] &&= args[:output].to_sym
+          if args[:methods]
+            if args[:methods].kind_of?(String) && args[:methods].match(/^\[.+\]$/)
+              args[:methods] = JSON.parse(args[:methods]).map(&:to_sym)
+            elsif args[:methods].kind_of?(Array)
+              args[:methods].map!(&:to_sym)
+            end
+          end
+          args
+        end
+      end
+    end
+  end
+end

data/lib/cardio/logger/request.rb

@@ -0,0 +1,40 @@
+require 'csv'
+
+module Cardio
+  class Logger
+    class Request
+      class << self
+        def path
+          path = Card.paths['request_log']&.first || File.dirname(Card.paths['log'].first)
+          filename = "#{Date.today}_#{Rails.env}.csv"
+          File.join path, filename
+        end
+
+        def write_log_entry controller
+          env = controller.env
+          return if env["REQUEST_URI"] =~ %r{^/files?/}
+
+          controller.instance_eval do
+            log = []
+            log << (Card::Env.ajax? ? "YES" : "NO")
+            log << env["REMOTE_ADDR"]
+            log << Card::Auth.current_id
+            log << card.name
+            log << action_name
+            log << params['view'] || (s = params['success'] and  s['view'])
+            log << env["REQUEST_METHOD"]
+            log << status
+            log << env["REQUEST_URI"]
+            log << DateTime.now.to_s
+            log << env['HTTP_ACCEPT_LANGUAGE'].to_s.scan(/^[a-z]{2}/).first
+            log << env["HTTP_REFERER"]
+
+            File.open(Request.path, "a") do |f|
+              f.write CSV.generate_line(log)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cardio/logger.rb

@@ -0,0 +1,11 @@
+
+module Cardio
+  class Logger
+    def self.with_logging method, opts, &block
+      return block.call unless Performance.enabled_method? method
+      Performance.with_timer(method, opts) do
+        block.call
+      end
+    end
+  end
+end

data/set/all/logger.rb

@@ -0,0 +1,55 @@
+event :start_performance_logger_on_change, before: :act,
+                                           when: :performance_log? do
+  start_performance_logger
+  @handle_logger = true
+end
+
+event :stop_performance_logger_on_change, after: :act,
+                                          when: :performance_log? do
+  stop_performance_logger
+  @handle_logger = false
+end
+
+event :start_performance_logger_on_read, before: :show_page, on: :read,
+                                         when: :performance_log?  do
+  start_performance_logger unless @handle_logger
+end
+
+event :stop_performance_logger_on_read, after: :show_page, on: :read,
+                                        when: :performance_log? do
+  stop_performance_logger unless @handle_logger
+end
+
+event :request_logger, after: :show_page, when: :request_logger? do
+  Cardio::Logger::Request.write_log_entry Env[:controller]
+end
+
+def request_logger?
+  Card.config.request_logger
+end
+
+def start_performance_logger
+  if Env.params[:performance_log]
+    Cardio::Logger::Performance.load_config Env.params[:performance_log]
+  end
+  if (request = Env[:controller]&.request)
+    method = request.env["REQUEST_METHOD"]
+    path   = request.env["PATH_INFO"]
+  else
+    method = "no request"
+    path = "no path"
+  end
+  Cardio::Logger::Performance.start method: method, message: path, category: "format"
+end
+
+def stop_performance_logger
+  Cardio::Logger::Performance.stop
+  return unless Env.params[:perfomance_log]
+  Cardio::Logger::Performance.load_config(Card.config.performance_logger || {})
+end
+
+def performance_log?
+  Card::Env.params[:performance_log] || Card.config.performance_logger
+end
+
+

data/set/right/performance_log.rb

@@ -0,0 +1,70 @@
+def log_dir
+  dir = File.join File.dirname(Decko.paths['log'].existent.first), 'performance'
+  Dir.mkdir dir unless Dir.exists? dir
+  dir
+end
+
+def log_path item
+  File.join log_dir, "#{item.gsub('/','_').gsub(/[^0-9A-Za-z.\-]/, '_')}.log"
+end
+
+def csv_path
+  File.join log_dir, "#{cardname.safe_key}.csv"
+end
+
+def add_log_entry request, html_log
+  time = DateTime.now.utc.strftime "%Y%m%d%H%M%S"
+  item_name = "%s+%s %s" % [name, time, request.gsub('/','/') ]
+  if include_item? item_name
+    item_name += 'a'
+    while include_item? item_name
+     item_name.next!
+    end
+  end
+
+  Card::Auth.as_bot do
+    File.open(log_path(item_name), 'w') {|f| f.puts html_log}
+    add_item! item_name
+  end
+end
+
+def add_csv_entry page, wbench_data, runs
+  if !File.exists? csv_path
+    File.open(csv_path, 'w') { |f| f.puts "page, render time, dom loading time, connection time, date"}
+  end
+  browser = wbench_data.browser
+  runs.times do |i|
+    csv_data = [
+      page,
+      browser['responseEnd'][i] - browser['requestStart'][i],
+      browser['domComplete'][i] - browser['domLoading'][i], # domLoadingTime
+      browser['requestStart'][i],  # domLoadingStart
+      DateTime.now.utc.inspect
+    ]
+    csv_line = CSV.generate_line(csv_data)
+    File.open(csv_path, 'a') { |f| f.puts csv_line }
+  end
+
+  if left != Card[:all]
+    all = Card.fetch "#{Card[:all].name}+#{Card[:performance_log].name}", :new=>{}
+    all.add_csv_entry page, wbench_data, runs
+  end
+end
+
+format :html do
+  view :core do
+    wagn_data =
+      card.item_names.map do |item|
+        path = card.log_path item
+        if File.exists? path
+          File.read(path)
+        end
+      end.compact.join "\n"
+    browser_data = CSV.parse(File.read(card.csv_path))
+    output [
+      table(browser_data, header: true),
+      wagn_data
+    ]
+  end
+end
+

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: card-mod-logger
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Philipp Kühl
+- Ethan McCutchen
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-10-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: card
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: customizable logging of decko request and performance meta data
+email:
+- info@decko.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/cardio/logger.rb
+- lib/cardio/logger/performance.rb
+- lib/cardio/logger/performance/big_brother.rb
+- lib/cardio/logger/performance/category_log.rb
+- lib/cardio/logger/performance/entry.rb
+- lib/cardio/logger/performance/html_formatter.rb
+- lib/cardio/logger/performance/text_formatter.rb
+- lib/cardio/logger/request.rb
+- set/all/logger.rb
+- set/right/performance_log.rb
+homepage: http://decko.org
+licenses:
+- GPL-3.0
+metadata:
+  card-mod: logger
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.28
+signing_key:
+specification_version: 4
+summary: request and performance logger for decko
+test_files: []