logfoo 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a9e14527e5a1943db7d50f730a72d3b5cf1ef318
-  data.tar.gz: 1272b5aa0c45b0fcc479bc71bdc58661adf8d074
+  metadata.gz: ee42d936b037ecb79f2b85171ee812bcd76c8047
+  data.tar.gz: c2c96c656ee3bb5a9b616f8b08868927063295f7
 SHA512:
-  metadata.gz: c5be6f234ee21b01a2a6ee246bdffa8a5adc8ea6f748d00f9975cae3793cd15b00b2c5cd26ab9b9f091536ec20adc8d4a6ce6d72325bcdec75294df88b1da011
-  data.tar.gz: 35d6cdb08f4a95dc274aa8c7f298ef9c4f105fa672d667e4dca626fc2f0ef38a7d16b06ab7906c11674829cbff2dabb551f71ba0f0dc3fc582877a9449a30037
+  metadata.gz: ef45863c233793cc602e7ee1f5b2c6fff8de285e4b9f5b8a8979f9cf6b7293e26e4a8a50df71c82e01ada987077271f68dccfa11e5f1719b8ebb6470622c417a
+  data.tar.gz: 4bd410dfcb13c9b593b9b00f206daf0a9685b3fd661c4080f23d06b4947410d1b5e54aa7af780a1ea280f91f8dd5e70829fcc53213c78f807232bfe3a408a144

data/lib/logfoo/app.rb

@@ -6,9 +6,13 @@ module Logfoo
 
     include Singleton
 
+    IGNORE_ME_ERROR = RuntimeError.new("ignore me")
+
     def initialize
       @queue = Queue.new
       @lock  = Mutex.new
+
+      start
     end
 
     def start
@@ -38,15 +42,6 @@ module Logfoo
 
     private
 
-      def new_entry(msg)
-        Entry.new(
-          :info,
-          Time.now,
-          self.class,
-          msg
-        )
-      end
-
       def main_loop ; Thread.new do
         begin
           loop do
@@ -55,42 +50,44 @@ module Logfoo
               break
             end
             if entry == :boom
-              raise RuntimeError.new("ignore me")
+              raise IGNORE_ME_ERROR
             end
-            App.append(entry)
+            App._append(entry)
+            App._handle_exception(entry) if entry.is_a?(ExceptionEntry)
           end
         rescue Exception => ex
-          App.handle_exception(ex, self.class)
+          entry = ExceptionEntry.build(self.class, ex)
+          App._handle_exception(entry)
           retry
         end
       end ; end
   end
 
-  class App
-    class << self
-      @@appenders          = [IoAppender.new]
-      @@exception_handlers = [StderrExceptionHanlder.new]
+  class App ; class << self
+    @@appenders          = []
+    @@exception_handlers = []
 
-      def appenders(*fn)
-        @@appenders = fn.flatten
-      end
+    def appenders(*fn)
+      @@appenders = fn.flatten
+    end
 
-      def exception_handlers(*fn)
-        @@exception_handlers = fn.flatten
-      end
+    def exception_handlers(*fn)
+      @@exception_handlers = fn.flatten
+    end
 
-      def append(entry)
-        @@appenders.each{|fn| fn.call(entry) }
-      end
+    def _handle_exception(entry)
+      @@exception_handlers.each{|fn| fn.call(entry) }
+    end
 
-      def handle_exception(ex, scope = nil, context = {})
-        @@exception_handlers.each{|fn| fn.call(ex, scope, context) }
-      end
+    def _append(entry)
+      @@appenders.each{|fn| fn.call(entry) }
+    end
 
-      def reset!
-        @@appenders          = [IoAppender.new]
-        @@exception_handlers = [StderrExceptionHanlder.new]
-      end
+    def _reset!
+      appenders IoAppender.new
+      exception_handlers StderrExceptionHanlder.new
     end
-  end
+  end ; end
+
+  App._reset!
 end

data/lib/logfoo/appenders/io_appender.rb

@@ -7,7 +7,11 @@ module Logfoo
     end
 
     def call(entry)
-      @io.write @formatter.call(entry)
+      write @formatter.call(entry)
+    end
+
+    def write(body)
+      @io.write body
       @io.flush
     end
   end

data/lib/logfoo/context.rb

@@ -41,14 +41,7 @@ module Logfoo
 
         entry =
           if message.is_a?(Exception)
-            ExceptionEntry.new(
-              level_id,
-              Time.now,
-              @scope,
-              message,
-              payload,
-              Thread.current.object_id
-            )
+            ExceptionEntry.build(@scope, message, payload, level: level_id)
           else
             Entry.new(
               level_id,

data/lib/logfoo/entry.rb

@@ -4,7 +4,7 @@ module Logfoo
       {
         level:   level   || :info,
         time:    time    || Time.now,
-        message: message,
+        msg:     message,
         scope:   scope,
       }.merge!(
         payload || {}
@@ -15,13 +15,26 @@ module Logfoo
   end
 
   ExceptionEntry = Struct.new(:level, :time, :scope, :exception, :payload, :thread) do
+    class << self
+      def build(scope, ex, payload = nil, options = {})
+        self.new(
+          options[:level],
+          Time.now,
+          scope,
+          ex,
+          payload,
+          Thread.current.object_id
+        )
+      end
+    end
+
     def to_h
       {
         level:     level || :error,
         time:      time  || Time.now,
-        message:   exception.message,
+        msg:       exception.message,
         scope:     scope,
-        exception: exception.class.to_s,
+        err:       exception.class.to_s,
       }.merge!(
         payload || {}
       ).merge!(

data/lib/logfoo/exception_handlers/stderr_exception_handler.rb

@@ -1,13 +1,24 @@
 module Logfoo
 
   class StderrExceptionHanlder
+    BACKTRACE_LINE   = "\t%s\n".freeze
+    EXCEPTION_LINE   = "%s: %s\n".freeze
+
     def initialize(appender = nil)
       @appender = appender || IoAppender.new(STDERR)
     end
 
-    def call(ex, scope, context)
-      entry = ExceptionEntry.new(nil, nil, scope, ex, context)
-      @appender.call(entry)
+    def call(entry)
+      @appender.write format(entry)
+    end
+
+    def format(entry)
+      values = []
+      values << (EXCEPTION_LINE % [entry.exception.class, entry.exception.message])
+      if entry.exception.backtrace.is_a?(Array)
+        values << entry.exception.backtrace.map{|l| BACKTRACE_LINE % l }.join
+      end
+      values.join
     end
   end
 

data/lib/logfoo/formatters/logfmt_formatter.rb

@@ -1,15 +1,15 @@
+require 'time'
+
 module Logfoo
   class LogfmtFormatter
 
-    UNESCAPED_STRING = /\A[\w\.\-\+\%\,\:\;\/]*\z/i
-
-    IGNORED_FIELDS = [:time]
+    UNESCAPED_STRING = /\A[\w\.\-\+\%\,\:\;\/]*\z/i.freeze
+    IGNORED_KEYS     = [:time]
+    FLOAT_FORMAT     = '%0.4f'.freeze
 
     def call(entry)
       case entry
-      when ExceptionEntry
-        format_exception(entry)
-      when Entry
+      when ExceptionEntry, Entry
         format_entry(entry)
       else
         entry.to_s
@@ -22,20 +22,9 @@ module Logfoo
         "#{format_hash(entry.to_h)}\n"
       end
 
-      def format_exception(entry)
-        values = ""
-        values << "#{format_hash(entry.to_h)}\n"
-        if entry.exception && entry.exception.backtrace.is_a?(Array)
-          values <<
-            "#{entry.exception.class}: #{entry.exception.message}\n" +
-            entry.exception.backtrace.map{|l| "\t#{l}\n" }.join
-        end
-        values
-      end
-
       def format_hash(attrs)
         attrs.inject([]) do |ac, (k,v)|
-          if !IGNORED_FIELDS.include?(k) && !(v == nil || v == "")
+          if !IGNORED_KEYS.include?(k) && !(v == nil || v == "")
             new_value = sanitize(v)
             ac << "#{k}=#{new_value}"
           end
@@ -46,17 +35,19 @@ module Logfoo
       def sanitize(v)
         case v
         when ::Array
-          may_quote v.join(",")
+          may_quote v.map{|i| i.to_s}.join(",")
         when ::Integer, ::Symbol
           v.to_s
         when ::Float
-          "%0.4f" % v
-        when ::TrueClass, ::FalseClass
-          v ? "t" : "f"
-        when Time
-          quote v.utc.to_s
+          FLOAT_FORMAT % v
+        when ::TrueClass
+          :t
+        when ::FalseClass
+          :f
+        when ::Time
+          v.utc.iso8601
         else
-          may_quote(v.to_s)
+          may_quote v.to_s
         end
       end
 

data/lib/logfoo/formatters/simple_formatter.rb

@@ -1,21 +1,23 @@
 module Logfoo
   class SimpleFormatter < LogfmtFormatter
 
+    FORMAT = "[%5s]: %s -%s%s".freeze
+
     private
 
       def format_hash(attrs)
         level   = attrs.delete(:level)
-        message = attrs.delete(:message)
+        message = attrs.delete(:msg)
         scope   = attrs.delete(:scope)
 
-        IGNORED_FIELDS.each do |f|
+        IGNORED_KEYS.each do |f|
           attrs.delete(f)
         end
 
         payload = super(attrs)
         payload = payload.empty? ? "" : " [#{payload}]"
         message = message.to_s.empty? ? "" : " #{message}"
-        "[%5s]: #{scope} -#{message}#{payload}" % level.upcase
+        FORMAT % [level.upcase, scope, message, payload]
       end
   end
 end

data/lib/logfoo/integrations/hutch.rb

@@ -0,0 +1,36 @@
+require 'hutch'
+
+module Logfoo ; module Hutch
+  class ErrorHandler
+    attr_reader :bunny_log, :hutch_log
+
+    class << self
+      attr_accessor :handler
+    end
+
+    ID = 'Hutch'.freeze
+
+    def initialize
+      @hutch_log = Logfoo.get_logger(ID)
+      @bunny_log = Logfoo.get_logger('Bunny')
+      @bunny_log.level = Logfoo::WARN
+    end
+
+    def handle(message_id, payload, consumer, ex)
+      entry = Context.build(
+        ID,
+        ex,
+        payload:    payload,
+        consumer:   consumer,
+        message_id: message_id
+      )
+      App.instance.append(entry)
+    end
+  end
+end ; end
+
+Logfoo::Hutch::ErrorHandler.handler = Logfoo::Hutch::ErrorHandler.new
+
+Hutch::Logging.logger = Logfoo::Hutch::ErrorHandler.handler.hutch_log
+Hutch::Config.set(:error_handlers, [Logfoo::Hutch::ErrorHandler.handler])
+Hutch::Config.set(:client_logger,   Logfoo::Hutch::ErrorHandler.handler.bunny_log)

data/lib/logfoo/integrations/rack/err.rb

@@ -0,0 +1,58 @@
+module Logfoo::Rack
+
+  class Err
+
+    TEXT_PLAIN            = 'text/plain'.freeze
+    CLEAN_RE              =  /\A(rack|puma)\./.freeze
+
+    FRAMEWORK_ERRORS      = %w{ action_dispatch.exception sinatra.error }.freeze
+
+    INTERNAL_SERVER_ERROR = [
+      500,
+      {
+        R::CONTENT_TYPE   => TEXT_PLAIN,
+        R::CONTENT_LENGTH => Rack::Utils::HTTP_STATUS_CODES[500].bytesize
+      },
+      [Rack::Utils::HTTP_STATUS_CODES[500]],
+    ].freeze
+
+    def initialize(app, log = nil)
+      @app = app
+    end
+
+    def call(env)
+      response = @app.call(env)
+
+      if framework_error = FRAMEWORK_ERRORS.find { |k| env[k] }
+        append(framework_error, env)
+      end
+
+      response
+    rescue Exception => e
+      append(e, env)
+      INTERNAL_SERVER_ERROR
+    end
+
+    private
+
+    def append(e, env)
+      env   = clean_env(env)
+      entry = Logfoo::ExceptionEntry.build(LOGGER_NAME, e, env)
+      Logfoo::App.instance.append(entry)
+    end
+
+    def clean_env(env)
+      env.inject({}) do |ac, (key, value) |
+        case
+        when key =~ CLEAN_RE
+          ac
+        else
+          ac.merge!(key => value)
+        end
+      end
+    end
+
+  end
+end
+
+

data/lib/logfoo/integrations/rack/log.rb

@@ -0,0 +1,52 @@
+module Logfoo::Rack
+
+  class Log
+
+    IGNORED              = %w{ /health /_ping }.freeze
+    HTTP_X_FORWARDED_FOR = 'HTTP_X_FORWARDED_FOR'.freeze
+    REMOTE_ADDR          = 'REMOTE_ADDR'.freeze
+
+    def initialize(app, log = nil)
+      @log = log || Logfoo.get_logger(LOGGER_NAME)
+      @app = app
+    end
+
+    def call(env)
+      began_at = Time.now
+      status, header, body = @app.call(env)
+      header = R::Utils::HeaderHash.new(header)
+      body   = R::BodyProxy.new(body) { log(env, status, header, began_at, body) }
+      [status, header, body]
+    end
+
+    private
+
+    def log(env, status, header, began_at, body)
+      return if ignored?(status, env)
+
+      now    = Time.now
+      addr   = (env[HTTP_X_FORWARDED_FOR] || env[REMOTE_ADDR]).to_s.split(", ").first
+      method = env[R::REQUEST_METHOD]
+      path   = env[R::PATH_INFO]
+
+      payload = {
+        method:   method,
+        path:     path,
+        query:    env[R::QUERY_STRING],
+        status:   status.to_s[0..3],
+        len:      header[R::CONTENT_LENGTH] || 0,
+        addr:     addr,
+        duration: now - began_at
+      }
+
+      @log.info [method, path].join(" "), payload
+    end
+
+    def ignored?(status, env)
+      status > 199 && status < 299 && IGNORED.include?(env[R::PATH_INFO])
+    end
+
+  end
+end
+
+

data/lib/logfoo/integrations/rack.rb

@@ -0,0 +1,9 @@
+require 'rack'
+
+module Logfoo ; module Rack
+  R = ::Rack
+  LOGGER_NAME = 'Rack'.freeze
+end ; end
+
+require File.expand_path("../rack/err", __FILE__)
+require File.expand_path("../rack/log", __FILE__)

data/lib/logfoo/version.rb

@@ -1,3 +1,3 @@
 module Logfoo
-  VERSION = '0.0.7'
+  VERSION = '0.0.8'
 end

data/lib/logfoo.rb

@@ -8,18 +8,17 @@ module Logfoo
 
   LEVELS = ['TRACE', 'DEBUG', 'INFO', 'WARN', 'ERROR', 'FATAL'].freeze
 
-  def self.get_logger(scope, context = nil)
-    App.instance.start unless App.instance.started?
+  autoload :Rack, File.expand_path("../logfoo/integrations/rack", __FILE__)
+
+  extend self
+
+  def get_logger(scope, context = nil)
     Context.new(App.instance, scope.to_s, context)
   end
 
-  def self.stop
+  def stop
     App.instance.stop
   end
-
-  def self.handle_exception(*args)
-    App.handle_exception(*args)
-  end
 end
 
 %w{
@@ -30,9 +29,8 @@ end
   exception_handlers/stderr_exception_handler
   app
   context
-  middlewares/err_middleware
-  middlewares/log_middleware
-  middlewares/hutch_error_handler
 }.each do |f|
   require File.expand_path("../logfoo/#{f}", __FILE__)
 end
+
+at_exit { Logfoo.stop }

data/logfoo.gemspec

@@ -28,7 +28,8 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler", "~> 1.11"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake",    "~> 10.0"
+  spec.add_development_dependency 'rack-test'
   spec.add_development_dependency "minitest"
   spec.add_development_dependency "minitest-reporters"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logfoo
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors:
 - Dmitry Galinsky
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-02-17 00:00:00.000000000 Z
+date: 2016-02-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -89,9 +103,10 @@ files:
 - lib/logfoo/exception_handlers/stderr_exception_handler.rb
 - lib/logfoo/formatters/logfmt_formatter.rb
 - lib/logfoo/formatters/simple_formatter.rb
-- lib/logfoo/middlewares/err_middleware.rb
-- lib/logfoo/middlewares/hutch_error_handler.rb
-- lib/logfoo/middlewares/log_middleware.rb
+- lib/logfoo/integrations/hutch.rb
+- lib/logfoo/integrations/rack.rb
+- lib/logfoo/integrations/rack/err.rb
+- lib/logfoo/integrations/rack/log.rb
 - lib/logfoo/version.rb
 - logfoo.gemspec
 homepage: https://github.com/dmexe/logfoo

data/lib/logfoo/middlewares/err_middleware.rb

@@ -1,48 +0,0 @@
-require 'rack'
-
-module Logfoo
-  class ErrMiddleware
-
-    def initialize(app, log = nil)
-      @log = log || Logfoo.get_logger('Rack')
-      @app = app
-    end
-
-    def call(env)
-      @app.call(env)
-    rescue Exception => e
-      @log.error(e, clean_env(env))
-      body = dump_exception(e)
-      [
-        500,
-        {
-          Rack::CONTENT_TYPE   => 'text/plain',
-          Rack::CONTENT_LENGTH => Rack::Utils.bytesize(body).to_s,
-        },
-        [body],
-      ]
-    end
-
-    private
-
-    def clean_env(env)
-      env.inject({}) do |ac, pair|
-        case
-        when pair[0] =~ /\A(rack|puma)\./
-          ac
-        else
-          ac.merge! pair[0] => pair[1]
-        end
-      end
-    end
-
-    def dump_exception(exception)
-      string = "#{exception.class}: #{exception.message}\n"
-      string << exception.backtrace.map { |l| "\t#{l}" }.join("\n")
-      string
-    end
-
-  end
-end
-
-

data/lib/logfoo/middlewares/hutch_error_handler.rb

@@ -1,13 +0,0 @@
-module Logfoo
-  class HutchErrorHandler
-    def handle(message_id, payload, consumer, ex)
-      Logfoo.handle_exception(
-        ex,
-        "Hutch",
-        payload:    payload,
-        consumer:   consumer,
-        message_id: message_id
-      )
-    end
-  end
-end

data/lib/logfoo/middlewares/log_middleware.rb

@@ -1,54 +0,0 @@
-require 'rack'
-
-module Logfoo
-
-  class LogMiddleware
-    FORMAT  = %{%s "%s %s%s %s" %d %s %0.4f}
-    IGNORED = %w{ /health /_ping }
-
-    def initialize(app, log = nil)
-      @log = log || Logfoo.get_logger('Rack')
-      @app = app
-    end
-
-    def call(env)
-      began_at = Time.now
-      status, header, body = @app.call(env)
-      header = Rack::Utils::HeaderHash.new(header)
-      body   = Rack::BodyProxy.new(body) { log(env, status, header, began_at) }
-      [status, header, body]
-    end
-
-    private
-
-    def log(env, status, header, began_at)
-      return if ignored?(status, env)
-
-      now    = Time.now
-      length = extract_content_length(header)
-      peer   = env['HTTP_X_FORWARDED_FOR'] || env["REMOTE_ADDR"]
-
-      payload = {
-        method:   env[Rack::REQUEST_METHOD],
-        path:     env[Rack::PATH_INFO],
-        query:    env[Rack::QUERY_STRING],
-        status:   status.to_s[0..3],
-        len:      length,
-        peer:     peer,
-        duration: now - began_at
-      }
-
-      @log.info "request", payload
-    end
-
-    def extract_content_length(headers)
-      headers[Rack::CONTENT_LENGTH] || 0
-    end
-
-    def ignored?(status, env)
-      status > 199 && status < 299 && IGNORED.include?(env[Rack::PATH_INFO])
-    end
-  end
-end
-
-