tracee 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 35e0c1ca049152c29c82fc41fb10eb9c5b5e4ae3
+  data.tar.gz: 6a5655c070b8a7d3a1702ce2ac60f38db4eb1912
+SHA512:
+  metadata.gz: 89ebe61689eb24b7d43b45e7c3ad00617940f117dffda032a2a1417ce8d9cdb4dae08c4569a17a8f2a08239fa86f78df7db27b0616d50ddfbf110c5825a9da13
+  data.tar.gz: 7797753852f37ef9141a7bd1edde46d7ac126241063634cf806c911e92a1132ba784360e5e3f85ccfef0a46efc697b70f62c8cc5708b69584810b8ae6bd8f32b

data/.gitignore

@@ -0,0 +1,19 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/tmp/
+
+.directory
+*.log
+*.bak
+*.old
+*.gem
+
+/auth.yml
+/feed.json

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--require spec_helper
+--format documentation

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.3
+before_install: gem install bundler -v 1.10.6

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in tracee.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Sergey Baev, https://github.com/tinbka
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,36 @@
+# Tracee
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/tracee`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'tracee'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install tracee
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake false` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/tracee.
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "tracee"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/tracee/benchmarkable.rb

@@ -0,0 +1,113 @@
+module Tracee
+  # Suppose, we have a code that works too slow, still it runs for 50ms.
+  # You measure time in 5 points between calls, and it gives you the first time:
+  #   0.025997, 0.012339, 0.037864, 0.0415
+  # the next time:
+  #   0.01658, 0.011366, 0.046607, 0.052117
+  # the third time:
+  #   0.016733, 0.011295, 0.032805, 0.036667
+  # How long has each block of code been executed _actualy_?
+  # The code runtime may fluctuate slightly because a PC does some work beside your benchmarking.
+  # The less the code runtime, the more relative fluctuations are. Thats why we do enough passes to minify them.
+  #
+  # This module allows to not only measure time between arbitrary calls (ticks),
+  # and not only get an average from multiple repeats of a block,
+  # but to get a list of averages between each arbitrary call (tick) in a block.
+  #
+  # Here's a sample:
+  #
+  #> $log.benchmark(times:20) {Ability.new(u)}
+  #  23:29:59.021 INFO [ability.rb:76 :assistant_permissions]: [tick +0.576797] 
+  #  23:29:59.034 INFO [ability.rb:84 :assistant_permissions]: [tick +0.245685] 
+  #  23:29:59.075 INFO [ability.rb:93 :assistant_permissions]: [tick +0.728214] 
+  #  23:29:59.120 INFO [ability.rb:111 :assistant_permissions]: [tick +0.866646] 
+  #  23:29:59.120 INFO [(irb):8 :irb_binding]: [tick +0.000559] [120.978946ms each; 2419.578914ms total] #<Ability:0x000000088c89c8>
+  module Benchmarkable
+    
+    def benchmark(times: 1, &block)
+      @benchmark = Benchmark.new
+      before_proc = Time.now
+      
+      (times - 1).times {yield}
+      @benchmark.last_pass!
+      result = yield
+      
+      now = Time.now
+      @benchmark = nil
+      
+      diff_ms = (now - before_proc)*1000
+      milliseconds_each = highlight_time_diff(diff_ms/times)
+      milliseconds_total = highlight_time_diff(diff_ms)
+      info "[#{milliseconds_each}ms each; #{milliseconds_total}ms total] #{result}", caller_at: 1
+    end
+    
+    def tick(msg='', caller_offset: 0)
+      now = Time.now
+      
+      if @benchmark
+        if prev = Thread.current[:tracee_checkpoint]
+          tick_diff = @benchmark.add_time(now - prev)
+          if @benchmark.last_pass
+            info "[tick +#{highlight_time_diff(tick_diff)}] #{msg}", caller_at: caller_offset+1
+          end
+          @benchmark.next
+        # else we just write `now' to a thread var
+        end
+      else
+        if prev = Thread.current[:tracee_checkpoint]
+          info "[tick +#{highlight_time_diff(now - prev)}] #{msg}", caller_at: caller_offset+1
+        else
+          info "[tick] #{msg}", caller_at: caller_offset+1
+        end
+      end
+      
+      Thread.current[:tracee_checkpoint] = now
+      nil
+    end
+    
+    def tick!(msg='', caller_offset: 0)
+      @benchmark.first! if @benchmark
+      Thread.current[:tracee_checkpoint] = nil
+      
+      tick msg, caller_offset: caller_offset+1
+    end
+    
+    
+    private
+    
+    def highlight_time_diff(diff)
+      diff.round(6).to_s.sub(/(\d+)\.(\d{0,3})(\d*)$/) {|m| "#$1.".light_white + $2.white + $3.light_black}
+    end
+    
+  end
+  
+  
+  class Benchmark
+    attr_reader :ticks_diffs, :last_pass, :tick_number
+    
+    def initialize
+      @ticks_diffs = Hash.new {|h, k| h[k] = 0}
+    end
+    
+    def last_pass!
+      @last_pass = true
+    end
+    
+    def first!
+      @tick_number = 0
+    end
+    
+    def next
+      @tick_number += 1
+    end
+    
+    def add_time(amount)
+      @ticks_diffs[@tick_number] += amount
+    end
+    
+    def tick_diff
+      @ticks_diffs[@tick_number]
+    end
+    
+  end
+end

data/lib/tracee/engine.rb

@@ -0,0 +1,18 @@
+begin
+  require 'rails'
+
+  module Tracee
+    class Engine < Rails::Engine
+
+      initializer "tracee.decorate_stack" do |app|
+        if defined? ::BetterErrors
+          Tracee.decorate_better_errors_stack
+        else
+          Tracee.decorate_active_support_stack
+        end
+      end
+        
+    end
+  end
+rescue LoadError
+end

data/lib/tracee/ext/active_support.rb

@@ -0,0 +1,51 @@
+module Tracee
+  module Extensions
+    module ActiveSupport
+      
+      module BacktraceCleaner
+        extend ::ActiveSupport::Concern
+        
+        included do
+          if defined? Rails
+            Rails.backtrace_cleaner.add_silencer {|line| line =~ IGNORE_RE}
+          end
+          alias_method_chain :clean, :decorate
+        end
+          
+        def clean_with_decorate(backtrace, kind=:silent)
+          Stack::BaseDecorator.(clean_without_decorate(backtrace, kind))
+        end
+          
+      end
+      
+      module TaggedLogging
+        module Formatter
+          extend ::ActiveSupport::Concern
+          
+          # Well, metaprogamming is a game you can play together!
+          # We do it so that Tracee::Logger would not have to care about an arity of corresponding #call or whatever.
+          included do
+            def self.extended(a_formatter_to_apply_tagging_on)
+              if a_formatter_to_apply_tagging_on.is_a? Tracee::Preprocessors::Base
+                a_formatter_to_apply_tagging_on.instance_variable_set\
+                  :@original_call,
+                  a_formatter_to_apply_tagging_on.class
+                    .instance_method(:call)
+                    .bind(a_formatter_to_apply_tagging_on)
+                
+                a_formatter_to_apply_tagging_on.class_eval do
+                  def call(severity, timestamp, progname, msg, caller_slice=[])
+                    @original_call.(severity, timestamp, progname, "#{tags_text}#{msg}", caller_slice)
+                  end
+                end
+              end
+            end
+          end
+          
+        end
+      end
+          
+        
+    end
+  end
+end

data/lib/tracee/ext/better_errors.rb

@@ -0,0 +1,29 @@
+module Tracee
+  module Extensions
+    module BetterErrors
+      module Middleware
+        extend ::ActiveSupport::Concern
+        
+        included do
+          alias_method_chain :log_exception, :decorate
+        end
+        
+        def log_exception_with_decorate
+          return unless ::BetterErrors.logger
+
+          message = "\n#{@error_page.exception.class} - #{@error_page.exception.message}:\n"
+          
+          frames = @error_page.backtrace_frames # original definition
+          frames = frames.map(&:to_s).reject {|line| line =~ IGNORE_RE}
+          frames = Stack::BaseDecorator.(frames)
+          frames.each do |frame|
+            message << "  #{frame}\n"
+          end
+
+          ::BetterErrors.logger.fatal message
+        end
+        
+      end
+    end
+  end
+end

data/lib/tracee/ext/exception.rb

@@ -0,0 +1,68 @@
+module Tracee
+  module Extensions
+    module Exception
+      extend ActiveSupport::Concern
+      
+      included do
+        alias_method_chain :set_backtrace, :decorate
+        class_attribute :trace_decorator
+      end
+      
+      ## Gotcha:
+      # If you also set (e.g. in irbrc file) 
+      #
+      #   module Readline
+      #     alias :orig_readline :readline
+      #     def readline(*args)
+      #       ln = orig_readline(*args)
+      #       SCRIPT_LINES__['(irb)'] << "#{ln}\n"
+      #       ln
+      #     end
+      #   end
+      #
+      # it will be possible to fetch lines entered in IRB
+      # else format_trace would only read ordinary require'd files
+      ##
+      if RUBY_VERSION > '2.1'
+        
+        def set_backtrace_with_decorate(trace)
+          if decorator = self.class.trace_decorator
+            if trace.is_a? Thread::Backtrace
+              return trace
+            else
+              trace = decorator.(trace)
+            end
+          end
+          set_backtrace_without_decorate(trace)
+        end
+        
+      else
+        
+        def set_backtrace(trace)
+          if decorator = self.class.trace_decorator
+            trace = decorator.(trace)
+          end
+          set_backtrace_without_decorate(trace)
+        end
+        
+      end
+      
+      ## Use case: 
+      # We have some method that we don't want to crash application in production but want to have this crash potential been logged
+      #
+      # def unsured_method
+      #   ... some crashable calls ...
+      # rescue PotentialException
+      #   $!.log
+      # end
+      ##
+      def log
+        Rails.logger.error [
+              "The exception has been handled: #{self.class} — #{message.force_encoding('UTF-8')}:",
+              *Rails.backtrace_cleaner.clean(backtrace)
+            ]*"\n"
+      end
+          
+    end
+  end
+end

data/lib/tracee/logger.rb

@@ -0,0 +1,165 @@
+module Tracee
+  
+  class Logger
+    LEVELS = [
+      'DEBUG', # Low-level information for developers
+      'INFO', # Generic (useful) information about system operation
+      'WARN', ## A warning
+      'ERROR', # A handleable error condition
+      'FATAL', # An unhandleable error that results in a program crash
+      'UNKNOWN' # An unknown message that should always be logged
+    ].freeze
+    LEVEL_NAMES = LEVELS.map(&:downcase).freeze
+    
+    include Tracee::Benchmarkable
+    
+    
+    attr_reader :level, :preprocessors, :formatter, :streams
+    
+    
+    def initialize(stream: $stdout, streams: nil, formatter: {:formatter => :tracee}, preprocessors: [], level: :info)
+      @streams = []
+      streams ||= [stream]
+      streams.each {|item| add_stream item}
+      
+      if formatter.is_a? Hash
+        # `formatter=' can't accept *array
+        set_formatter *formatter.to_a.flatten
+      else
+        self.formatter = formatter
+      end
+      
+      @preprocessors = []
+      preprocessors.each {|item|
+        if item.is_a? Hash
+          add_preprocessor *item.to_a.flatten
+        else
+          add_preprocessor item
+        end
+      }
+      
+      self.level = level
+      read_log_level_from_env
+    end
+    
+    
+    def add_preprocessor(callable_or_symbol=nil, *preprocessor_params)
+      if callable_or_symbol.is_a? Symbol
+        @preprocessors << Tracee::Preprocessors.const_get(callable_or_symbol.to_s.camelize).new(*preprocessor_params)
+      elsif callable_or_symbol.respond_to? :call
+        @preprocessors << callable_or_symbol
+      else
+        raise TypeError, 'A preprocessor must respond to #call'
+      end
+    end
+    
+    def set_formatter(callable_or_symbol=nil, *formatter_params)
+      if callable_or_symbol.is_a? Symbol
+        @formatter = Tracee::Preprocessors.const_get(callable_or_symbol.to_s.camelize).new(*formatter_params)
+      elsif callable_or_symbol.respond_to? :call
+        @formatters = callable_or_symbol
+      else
+        raise TypeError, 'A formatter must respond to #call'
+      end
+    end
+    alias formatter= set_formatter
+    
+    def should_process_caller?
+      formatter.respond_to? :should_process_caller? and formatter.should_process_caller?
+    end
+    
+    def add_stream(target_or_stream)
+      if target_or_stream.is_a? Tracee::Stream
+        @streams << target_or_stream
+      else
+        @streams << Stream.new(target_or_stream)
+      end
+    end
+    
+    def level=(level)
+      @level = level.is_a?(Integer) ? level : LEVELS.index(level.to_s.upcase)
+    end
+    
+    alias log_level= level=
+    alias log_level level
+    
+    
+    def write(msg, progname, level, level_int, caller_slice=[])
+      now = DateTime.now
+      
+      catch :halt do
+        @preprocessors.each do |preprocessor|
+          msg = preprocessor.(level, now, progname, msg, caller_slice)
+        end
+        
+        msg = @formatter.(level, now, progname, msg, caller_slice)
+        
+        @streams.each do |stream|
+          stream.write msg, level_int, log_level
+        end
+      end
+      nil
+    end
+    
+    LEVELS.each_with_index do |level, level_int|
+      const_set level, level_int
+    
+      level_name = level.downcase
+    
+      class_eval <<-EOS, __FILE__, __LINE__+1
+        def #{level_name}(*args, &block)
+          return if @level > #{level_int}
+          
+          if block
+            msg = block.()
+            if args[0].is_a? Hash
+              caller_at = args[0][:caller_at] || 0
+            else
+              progname = args[0].to_s
+            end
+          else
+            msg = args[0]
+          end
+          
+          if should_process_caller?
+            caller = caller(1)
+            
+            caller_at ||= (args[1] || {})[:caller_at] || 0
+            if caller_at.is_a? Array
+              caller_slice = caller_at.map! {|i| caller[i]}
+            else
+              caller_slice = [*caller[caller_at]]
+            end
+          end
+            
+          write msg, progname, '#{level_name}', #{level_int}, caller_slice
+        end
+        
+        def #{level_name}?
+          @level <= #{level_int}
+        end
+      EOS
+    end
+    
+    alias <= debug
+    alias << info
+    alias < warn
+    
+    
+    private
+    
+    def read_log_level_from_env
+      if ENV['LOG_LEVEL'] and LEVELS.include? ENV['LOG_LEVEL']
+        self.log_level = ENV['LOG_LEVEL']
+      elsif ENV['DEBUG'] || ENV['VERBOSE']
+        self.log_level = 'DEBUG'
+      elsif ENV['WARN'] || ENV['QUIET']
+        self.log_level = 'WARN'
+      elsif ENV['SILENT']
+        self.log_level = 'ERROR'
+      end
+    end
+    
+  end
+  
+end

data/lib/tracee/preprocessors/base.rb

@@ -0,0 +1,15 @@
+module Tracee
+  module Preprocessors
+    class Base
+      
+      def call(msg_level, datetime, progname, msg, caller_slice=[])
+        msg
+      end
+      
+      def halt!
+        throw :halt
+      end
+      
+    end
+  end
+end

data/lib/tracee/preprocessors/formatter.rb

@@ -0,0 +1,135 @@
+module Tracee
+  module Preprocessors
+    class Formatter < Base
+      COLORED_LEVELS = {
+        'debug' => 'DEBUG'.white,
+        'info' => 'INFO'.light_cyan,
+        'warn' => 'WARN'.light_magenta,
+        'error' => 'ERROR'.light_yellow,
+        'fatal' => 'FATAL'.light_red,
+        'unknown' => 'UNKNOWN'.light_black
+      }.freeze
+      
+      UPCASE_LEVELS = Tracee::Logger::LEVEL_NAMES.map {|name| [name, name.upcase]}.to_h.freeze
+      
+      TEMPLATES = {
+        tracee: {
+          summary: "%{datetime} %{level} [%{caller}]: %{message}",
+          datetime: "%T.%3N",
+          level: COLORED_LEVELS,
+          caller: "#{'%{file}:%{line}'.white} #{':%{method}'.light_red}"
+        },
+        
+        logger_formatter: {
+          summary: "%{level_letter}, [%{datetime} #%{pid}] %{level} -- %{progname}: %{message}",
+          datetime: "%FT%T.%6N",
+          level: UPCASE_LEVELS
+        },
+        
+        plain: "%{message}",
+        
+        empty: ""
+      }.freeze
+      
+      TEMPLATE_KEYS = %w{datetime level level_letter pid progname caller message}.freeze
+      CALLER_KEYS = %W{path file line method}.freeze
+          
+      attr_reader :summary, :caller, :datetime, :level
+      
+      
+      # available template keys : datetime, level, level_letter, pid, thread_id, progname, caller, message
+      # available caller keys : path, file, line, method
+      # params : {
+      #    summary: <string containing available template keys as interpolation marks>,
+      #    datetime: <format available to DateTime#strftime>,   # optional
+      #    level: {<severity level name> => <label string>, ... },   # optional
+      #    caller: <string containing available caller keys as interpolation marks>   # required if summary refers caller
+      #  } 
+      def initialize(params_or_key)
+        if params_or_key.is_a? Symbol
+          params = TEMPLATES[params_or_key]
+        end
+        if params.is_a? String
+          params = {summary: params}
+        end
+        
+        unless params.is_a? Hash
+          raise TypeError, 'params must be a Hash or a reference to one of Tracee::Formatters::Template::TEMPLATES'
+        end
+        
+        @summary, @caller, @datetime, @level = params.values_at(:summary, :caller, :datetime, :level).map &:freeze
+        @references = TEMPLATE_KEYS.select {|key| @summary["%{#{key}}"]}.to_set
+      end
+      
+      
+      def call(msg_level, datetime, progname, msg, caller_slice=[])
+        result = @summary.dup
+        
+        if @references.include? 'datetime'
+          result.sub! '%{datetime}', datetime.strftime(@datetime || '%FT%T%Z')
+        end
+        
+        if @references.include? 'level' or @references.include? 'level_letter'
+          level = @level[msg_level] || msg_level
+          result.sub! '%{level}', level
+          result.sub! '%{level_letter}', level[0]
+        end
+        
+        if @references.include? 'pid'
+          result.sub! '%{pid}', Process.pid.to_s
+        end
+        
+        if @references.include? 'thread_id'
+          result.sub! '%{thread_id}', Thread.current.object_id
+        end
+        
+        if @references.include? 'progname'
+          result.sub! '%{progname}', progname
+        end
+        
+        if @references.include? 'caller'
+          caller_slice = caller_slice.reverse.map {|line|
+            path, file, line, is_block, block_level, method = line.match(CALLER_RE)[1..-1]
+            block_level ||= is_block && '1'
+            method = "#{method} {#{block_level}}" if block_level
+            @caller % {path: path, file: file, line: line, method: method}
+          } * ' -> '
+          result.sub! '%{caller}', caller_slice
+        end
+        
+        if @references.include? 'message'
+          if msg.nil?
+            msg = "\b\b"
+          elsif !msg.is_a?(String)
+            msg = msg.inspect
+          end
+          result.sub! '%{message}', msg
+        end
+        
+        return result + "\n"
+      end
+      
+      
+      def should_process_caller?
+        @references.include? 'caller'
+      end
+      
+      
+      def inspect
+        summary = @summary.dup
+        if @datetime
+          summary.sub!('%{datetime}', DateTime.parse('2000-10-20 11:22:33.123456789').strftime(@datetime))
+        end
+        if @level
+          summary.sub!('%{level}', "{#{@level.values*', '}}")
+          summary.sub!('%{level_letter}', "{#{@level.values.map {|w| w[0]}*', '}}")
+        end
+        if @caller
+          summary.sub!('%{caller}', @caller.to_s)
+        end
+        %{#{to_s.chop} "#{summary}">}
+      end
+      
+    end
+  end
+end

data/lib/tracee/preprocessors/quiet_assets.rb

@@ -0,0 +1,25 @@
+# quiet_assets gem works only on thread-safe environment or on multithreaded one with only few assets.
+# Known issue: https://github.com/evrone/quiet_assets/issues/40
+# I'd fix it so that it would always reset log_level to that of Rails.application.config.log_level
+# But such an approach will not allow to change log_level within runtime.
+#
+# Tracee deals with it in pretty straightforward manner. It just ignores whatever we do not care about.
+module Tracee
+  module Preprocessors
+    class QuietAssets < Base
+      
+      def initialize(assets_paths=['assets'])
+        @assets_paths_pattern = assets_paths * '|'
+      end
+    
+      def call(msg_level, datetime, progname, msg, caller_slice=[])
+        if msg =~ %r{^Started GET "/(#@assets_paths_pattern)/}
+          halt!
+        else
+          msg
+        end
+      end
+
+    end
+  end
+end

data/lib/tracee/stack/base_decorator.rb

@@ -0,0 +1,42 @@
+module Tracee
+  module Stack
+    module BaseDecorator
+    
+      # Make sure that Dir.pwd is the application root directory
+      def self.call(source)
+        return source if source.empty? or source[0]["\n"] # already decorated
+        
+        result, current_line_steps = [], []
+        # path, file, line, is_block, block_level, method
+        step_details = source[0].match(CALLER_RE)
+        
+        source.each_with_index do |step, i|
+          next_step_details = source[i+1] && source[i+1].match(CALLER_RE)
+          
+          if step_details and step_details[:path] !~ Tracee::IGNORE_RE
+            #if level = step_details[:block_level]
+            #  step = step.sub(/block (\(\d+ levels\) )?in/, "{#{level}}")
+            #end
+            if method = step_details[:method] and next_step_details and [step_details[:path], step_details[:line]] == [next_step_details[:path], next_step_details[:line]]
+              current_line_steps.unshift "`#{method}#{" {#{step_details[:block_level]}}" if step_details[:block_level]}'"
+            elsif step_details[:line].to_i > 0 and code_line = Tracee::Stack.readline(step_details[:path], step_details[:line].to_i)
+              current_line_steps.unshift step
+              result << "#{current_line_steps * ' -> '}\n   >>   #{code_line}"
+              current_line_steps = []
+            else
+              result << step
+            end
+          end
+          step_details = next_step_details
+        end
+        
+        if defined? IRB and IRB.conf[:BACK_TRACE_LIMIT] and result.size > IRB.conf[:BACK_TRACE_LIMIT] and result.last[-1] != "\n"
+          result.last << "\n"
+        end
+        
+        result
+      end
+    
+    end
+  end
+end

data/lib/tracee/stack.rb

@@ -0,0 +1,44 @@
+require 'tracee/stack/base_decorator'
+
+module Tracee
+  module Stack
+    SCRIPT_LINES_MTIMES = {}
+    
+    # Rails' autoreload of code doesn't rewrite SCRIPT_LINES__,
+    # to perform that automatically, Tracee::Stack.reload_script_lines should be turned on.
+    # This mattr is left writable mostly for debug purposes.
+    mattr_accessor :reload_script_lines
+    self.reload_script_lines = true
+    
+    def self.readlines(file)
+      if reload_script_lines
+        if File.exists?(file)
+          mtime = File.mtime(file)
+          unless SCRIPT_LINES_MTIMES[file] and SCRIPT_LINES_MTIMES[file] >= mtime
+            SCRIPT_LINES_MTIMES[file] = mtime
+            SCRIPT_LINES__[file] = IO.readlines(file)
+          end
+          SCRIPT_LINES__[file]
+        elsif lines = SCRIPT_LINES__[file]
+          lines
+        end
+      else
+        if lines = SCRIPT_LINES__[file]
+          lines
+        else
+          if File.exists?(file)
+            SCRIPT_LINES_MTIMES[file] = File.mtime(file)
+            SCRIPT_LINES__[file] = IO.readlines(file)
+          end
+        end
+      end
+    end
+    
+    def self.readline(file, line)
+      if lines = readlines(file)
+        (lines[line.to_i - 1] || "<line #{line} is not found> ").chomp.green
+      end
+    end
+  
+  end
+end

data/lib/tracee/stream.rb

@@ -0,0 +1,100 @@
+module Tracee
+  
+  class Stream
+    attr_reader :target
+    
+    class TargetError < TypeError
+      def initialize(message='A target must be IO | String | Hash{<level name> => <level log file path | IO>, ... } | Hash{:cascade => <level log file path pattern with "level" key>}', *) super end
+    end
+      
+    # @ target : IO | String | {<level name> => < level log file path | IO >, ... } | {:cascade => < level log file path pattern >}
+    # pattern example : "log/development.%{level}.log"
+    def initialize(target)
+      if target.is_a? Hash
+        raise TargetError if target.values.any? {|val| !( val.is_a? String or val.is_a? IO or val.is_a? StringIO )}
+        
+        if pattern = target[:cascade]
+          target = Tracee::Logger::LEVEL_NAMES.map {|name|
+            [name, pattern % {level: name}]
+          }.to_h
+        else
+          target = target.with_indifferent_access
+        end
+      
+      else
+        raise TargetError unless target.is_a? String or target.is_a? IO or target.is_a? StringIO
+      end
+
+      @target = target
+    end
+  
+    # cascade principle:
+    #
+    # logger.log_level = :debug
+    # logger.warn msg
+    #   development.debug.log << msg
+    #   development.info.log << msg
+    #   development.warn.log << msg
+    #   
+    # logger.log_level = :warn
+    # logger.error msg
+    #   development.warn.log << msg
+    #   development.error.log << msg
+    def write(msg, msg_level=nil, log_level=nil)
+      return if msg.nil?
+      
+      case @target
+      when Hash # cascade
+        Tracee::Logger::LEVEL_NAMES[log_level..msg_level].each do |name|
+          if target = @target[name]
+            io_write target, msg
+          end
+        end
+      else
+        io_write @target, msg
+      end
+    end
+    
+    alias << write
+    
+    private
+    
+    def io_write(target, msg)
+      case target
+      when IO, StringIO then target << msg
+      when String then File.open(target, 'a') {|f| f << msg}
+      end
+    end
+
+  end
+  
+  
+  class IndifferentStream < Stream
+    
+    class TargetError < TypeError
+      def initialize(message='A target must be an object implementing #<< method | Hash{<level name> => <such an object>, ... }', *) super end
+    end
+    
+    # @ target : IO | String | {<level name> => < level log file path | IO >, ... } | {:cascade => < level log file path pattern >}
+    # pattern example : "log/development.%{level}.log"
+    def initialize(target)
+      if target.is_a? Hash
+        raise TargetError if target.values.any? {|val| !val.respond_to? :<<}
+        
+        target = target.with_indifferent_access
+      else
+        raise TargetError unless target.respond_to? :<<
+      end
+
+      @target = target
+    end
+
+    private
+    
+    def io_write(target, msg)
+      target << msg
+    end
+
+  end
+    
+end

data/lib/tracee/version.rb

@@ -0,0 +1,3 @@
+module Tracee
+  VERSION = "0.1.0"
+end

data/lib/tracee.rb

@@ -0,0 +1,95 @@
+# When you working with IRB/Pry/Ripl it should be defined in according rc-file for all loaded ruby files to be cached into.
+unless defined? SCRIPT_LINES__
+  SCRIPT_LINES__ = {}
+end
+
+require 'active_support'
+require 'active_support/inflector'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/module/aliasing'
+require 'active_support/core_ext/class/attribute'
+require 'active_support/tagged_logging'
+
+require 'colorize'
+
+require 'tracee/version'
+require 'tracee/benchmarkable'
+require 'tracee/logger'
+require 'tracee/preprocessors/base'
+require 'tracee/preprocessors/formatter'
+require 'tracee/preprocessors/quiet_assets'
+require 'tracee/stream'
+require 'tracee/stack'
+require 'tracee/ext/exception'
+require 'tracee/ext/active_support'
+require 'tracee/ext/better_errors'
+require 'tracee/engine'
+
+module Tracee
+  CALLER_RE = \
+    %r{^(?<path>.*?(?<file>[^/\\]+?))#{ # ( path ( file ) ) 
+      }:(?<line>\d+)(?::in #{ # :( line )[ :in
+      }`(?<is_block>block (?:\((?<block_level>\d+) levels\) )?in )?(?<method>.+?)'#{ # `( [ block in ] closure )' ]
+      })?$}
+      
+  IGNORE_RE = \
+    %r{/irb(/|\.rb$)#{ # irb internals
+      }|lib/active_support/dependencies.rb$#{ # everywhere-proxy
+      }|^-e:#{ # ruby -e oneliner
+      }|^(script|bin)/#{ # other common entry points
+      }|/gems/bundler-\d|ruby-\d.\d.\d(@[^/]+)?/bin/#{ # bundle console
+      }|lib/rails/commands(/|\.rb$)#{ # rails console
+      }}
+      
+      
+  class ::Exception
+    include Tracee::Extensions::Exception
+  end
+  
+  module ::ActiveSupport::TaggedLogging::Formatter
+    include Tracee::Extensions::ActiveSupport::TaggedLogging::Formatter
+  end
+  
+  # Use `Tracee.decorate_stack_everywhere` only within a console, because it significantly slowdown rails middleware.
+  # So better put it into .irbrc or similar.
+  class << self
+    
+    def decorate_exceptions_stack
+      Exception.trace_decorator = Stack::BaseDecorator
+      
+      # These would extremely slowdown or stop runtime
+      [SystemStackError, NoMemoryError, NameError, defined?(IRB::Abort) && IRB::Abort].compact.each do |klass|
+        klass.trace_decorator = nil
+      end
+      
+      # But this NameError's subclass would not
+      NoMethodError.trace_decorator = Exception.trace_decorator
+    end
+    
+    def decorate_better_errors_stack(from_decorate_everywhere=false)
+      if defined? BetterErrors
+        BetterErrors::Middleware.class_eval do
+          include Tracee::Extensions::BetterErrors::Middleware
+        end
+      elsif !from_decorate_everywhere
+        warn "Tracee.decorate_better_errors_stack was ignored, because BetterErrors hadn't been defined."
+      end
+    end
+    
+    def decorate_active_support_stack
+      ActiveSupport::BacktraceCleaner.class_eval do
+        include Tracee::Extensions::ActiveSupport::BacktraceCleaner
+      end
+    end
+    
+    def decorate_stack_everywhere
+      decorate_exceptions_stack
+      decorate_better_errors_stack(true)
+      decorate_active_support_stack
+    end
+  
+  end
+  
+  
+  $log ||= Logger.new
+end

data/tracee.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'tracee/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "tracee"
+  spec.version       = Tracee::VERSION
+  spec.authors       = ["Sergey Baev"]
+  spec.email         = ["tinbka@gmail.com"]
+
+  spec.summary       = %q{An extensible logger with stack tracing, benchmarking, preprocessing, and severity-based output splitting}
+  spec.description   = %q{Tracee is a simple extensible logger with stack tracing, benchmarking, preprocessing, and severity-based output splitting. Tracee is meant for development and debugging of any type of application or library, and compatible with Rails. The main reason of its existence is to help you see through a stack.}
+  spec.homepage      = "https://github.com/tinbka/tracee"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.3"
+  
+  spec.add_dependency "colorize"
+  spec.add_dependency "activesupport"
+end

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification
+name: tracee
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sergey Baev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-11-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: colorize
+  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'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  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: Tracee is a simple extensible logger with stack tracing, benchmarking,
+  preprocessing, and severity-based output splitting. Tracee is meant for development
+  and debugging of any type of application or library, and compatible with Rails.
+  The main reason of its existence is to help you see through a stack.
+email:
+- tinbka@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/tracee.rb
+- lib/tracee/benchmarkable.rb
+- lib/tracee/engine.rb
+- lib/tracee/ext/active_support.rb
+- lib/tracee/ext/better_errors.rb
+- lib/tracee/ext/exception.rb
+- lib/tracee/logger.rb
+- lib/tracee/preprocessors/base.rb
+- lib/tracee/preprocessors/formatter.rb
+- lib/tracee/preprocessors/quiet_assets.rb
+- lib/tracee/stack.rb
+- lib/tracee/stack/base_decorator.rb
+- lib/tracee/stream.rb
+- lib/tracee/version.rb
+- tracee.gemspec
+homepage: https://github.com/tinbka/tracee
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: An extensible logger with stack tracing, benchmarking, preprocessing, and
+  severity-based output splitting
+test_files: []