logfoo 0.1.5 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d0187181bc8229a48109f4619d41604c388c3850
-  data.tar.gz: 823f317b5f1b427f7ccd9cd5630932460898f5c1
+  metadata.gz: 090c89addea5e5f294a83fc7118fc5f05eb7fcc2
+  data.tar.gz: e98d25ed50c2f2d443b3493b923924316b485620
 SHA512:
-  metadata.gz: acb902d5d0e238e22cbd1a0b3daf3fe4fb7b067b691f0515f96bcb14d0885b6f91ade64d2575647a83854b150f53f11ee82b4c517e4b1918e53298f11d8a4cd8
-  data.tar.gz: e36b75465178fd50d51123671b1c51124fe156356f35e672739c4f76603317067e0bbe3ae5b649c65db8e351c50b1a4aadfb9dc6aba1957710baf611fe743775
+  metadata.gz: b25cfaf625776d1424efdb87e0da631657633bd56d228dac97648b3466498bebff63cb8e1b26e6b3e2d89fc7119ba14df08444ebc66b6bdb55745fddb0958e3f
+  data.tar.gz: 2eb571f9dc9be891d7aaaaf972f4a2e5447c457a5c1787c0ca8989a196df17a5ef2c71789196d1930a56596e68758c30f606a3a9bbdb25b6c87a714462825d33

data/lib/logfoo/app.rb

@@ -37,8 +37,8 @@ module Logfoo
       end
     end
 
-    def append(entry)
-      @queue.push(entry) if @thread
+    def append(line)
+      @queue.push(line) if @thread
     end
 
     private
@@ -46,21 +46,21 @@ module Logfoo
       def main_loop ; Thread.new do
         begin
           loop do
-            entry = @queue.pop
-            case entry
+            line = @queue.pop
+            case line
             when :shutdown
               break
             when :boom
               raise IGNORE_ME_ERROR
-            when ExceptionEntry
-              App._handle_exception(entry)
+            when ErrLine
+              App._handle_exception(line)
             else
-              App._append(entry)
+              App._append(line)
             end
           end
         rescue Exception => ex
-          entry = ExceptionEntry.build(self.class, ex)
-          App._handle_exception(entry)
+          line = ErrLine.build(logger_name: self.class, exception: ex)
+          App._handle_exception(line)
           retry
         end
       end ; end

data/lib/logfoo/appenders/io_appender.rb

@@ -1,23 +1,21 @@
-module Logfoo
-  class IoAppender
-    def initialize(io = nil, formatter = nil)
-      @io        = io || STDOUT
+module Logfoo ; class IoAppender
+  def initialize(io = nil, formatter = nil)
+    @io        = io || STDOUT
 
-      if @io.respond_to?(:sync=)
-        @io.sync = true
-      end
-
-      is_tty     = @io.respond_to?(:tty?) && @io.tty?
-      @formatter = formatter || (is_tty ? SimpleFormatter.new : LogfmtFormatter.new)
+    if @io.respond_to?(:sync=)
+      @io.sync = true
     end
 
-    def call(entry)
-      write @formatter.call(entry)
-    end
+    is_tty     = @io.respond_to?(:tty?) && @io.tty?
+    @formatter = formatter || (is_tty ? SimpleFormatter.new : LogfmtFormatter.new)
+  end
 
-    def write(body)
-      @io.write body
-      @io.flush
-    end
+  def call(entry)
+    write @formatter.call(entry)
+  end
+
+  def write(body)
+    @io.write body
+    @io.flush
   end
-end
+end ; end

data/lib/logfoo/context.rb

@@ -1,100 +1,108 @@
-module Logfoo
-  class Context
+module Logfoo ; class Context
 
-    attr_reader :level, :name, :thread_id
+  attr_reader :level, :name, :thread_id, :measure
 
-    THREAD_CONTEXT = :"logfoo_context"
+  THREAD_CONTEXT = :"logfoo_context"
 
-    def initialize(app, name, context = nil)
-      @app          = app
-      @name         = name
-      @level        = Logfoo::DEBUG
-      @context      = context || {}
-    end
+  def initialize(app, name, context = nil)
+    @app     = app
+    @name    = name
+    @level   = Logfoo::DEBUG
+    @context = context || {}
+    @measure = Measure.new(self)
+  end
 
-    def level=(level)
-      @level = level.to_i
-    end
+  def level=(level)
+    @level = level.to_i
+  end
 
-    def []=(k,v)
-      if v == nil
-        @context.delete(k)
-      else
-        @context[k] = v
-      end
+  def []=(k,v)
+    if v == nil
+      @context.delete(k)
+    else
+      @context[k] = v
     end
+  end
 
-    def context(keys = nil)
-      if block_given?
-        keys ||= {}
-        begin
-          Thread.current[THREAD_CONTEXT] ||= []
-          Thread.current[THREAD_CONTEXT].push(keys)
-          yield
-        ensure
-          Thread.current[THREAD_CONTEXT].pop
-          if Thread.current[THREAD_CONTEXT] == []
-            Thread.current[THREAD_CONTEXT] = nil
-          end
+  def context(keys = nil)
+    if block_given?
+      keys ||= {}
+      begin
+        Thread.current[THREAD_CONTEXT] ||= []
+        Thread.current[THREAD_CONTEXT].push(keys)
+        yield
+      ensure
+        Thread.current[THREAD_CONTEXT].pop
+        if Thread.current[THREAD_CONTEXT] == []
+          Thread.current[THREAD_CONTEXT] = nil
         end
-      else
-        keys = (Thread.current[THREAD_CONTEXT] || []).inject({}) do |memo, kvs|
-          kvs.each do |(k,v)|
-            memo.merge!(k => v)
-          end
-          memo
+      end
+    else
+      keys = (Thread.current[THREAD_CONTEXT] || []).inject({}) do |memo, kvs|
+        kvs.each do |(k,v)|
+          memo.merge!(k => v)
         end
-        @context.merge(keys)
+        memo
       end
+      @context.merge(keys)
     end
+  end
 
-    def measure(message, payload = {})
-      tm = Time.now.to_f
-      re = nil
-      re = yield if block_given?
-      tm = Time.now.to_f - tm
-      payload[:duration] = tm
-      self.info message, payload
-      re
+  def add(level, message, progname, &block)
+    lv = Logfoo::LEVELS[level]
+    if lv
+      public_send(lv.downcase, message, &block)
     end
+  end
 
-    def add(level, message, progname, &block)
-      lv = Logfoo::LEVELS[level]
-      if lv
-        public_send(lv.downcase, message, &block)
-      end
+  Logfoo::LEVELS.each_with_index do |lv, idx|
+    define_method :"#{lv.downcase}?" do
+      idx >= level
     end
+  end
+
+  Logfoo::LEVELS.each_with_index do |lv, idx|
+    level_id = lv.downcase.to_sym
 
-    Logfoo::LEVELS.each_with_index do |lv, idx|
-      define_method :"#{lv.downcase}?" do
-        idx >= level
+    define_method level_id do |message = nil, payload = nil, &block|
+      if idx >= level
+        payload = context.merge(payload || {})
+        message = block ? _call_log_fn(block, payload) : message
+        line    = build_line(level_id, message, payload)
+        @app.append(line)
       end
     end
+  end
 
-    Logfoo::LEVELS.each_with_index do |lv, idx|
-      level_id = lv.downcase.to_sym
+  def _call_log_fn(fn, payload)
+    case fn.arity
+    when 0
+      fn.call
+    when 1
+      fn.call(payload)
+    else
+      raise RuntimeError, "invalid lambda arity, must be 0 or 1, was #{fn.arity}"
+    end
+  end
 
-      define_method level_id do |message = nil, payload = nil, &block|
-        if idx >= level
-          message = block ? block.call : message
-          payload = context.merge(payload || {})
+  private
 
-          entry =
-            if message.is_a?(Exception)
-              ExceptionEntry.build(@name, message, payload, level: level_id)
-            else
-              Entry.new(
-                level_id,
-                Time.now,
-                @name,
-                message,
-                payload,
-                Thread.current.object_id
-              )
-            end
-          @app.append(entry)
-        end
-      end
+  def build_line(level_id, message, payload)
+    if message.is_a?(Exception)
+      ErrLine.build(
+        logger_name: @name,
+        exception:   message,
+        payload:     payload,
+        level:       level_id
+      )
+    else
+      LogLine.build(
+        logger_name: @name,
+        message:     message,
+        payload:     payload,
+        level:       level_id
+      )
     end
   end
-end
+
+end ; end

data/lib/logfoo/entries.rb

@@ -0,0 +1,59 @@
+module Logfoo
+  LogLine = Struct.new(:level, :time, :logger_name, :message, :payload, :thread) do
+    class << self
+      def build(logger_name:, message:, payload: nil, level: nil)
+        self.new(
+          level || :info,
+          Time.now.utc,
+          logger_name,
+          message,
+          payload || {},
+          Thread.current.object_id
+        )
+      end
+    end
+
+    def to_h
+      {
+        level:   level,
+        time:    time,
+        msg:     message,
+        logger:  logger_name,
+      }.merge!(
+        payload
+      ).merge!(
+        thread:  thread
+      )
+    end
+  end
+
+  ErrLine = Struct.new(:level, :time, :logger_name, :exception, :payload, :thread) do
+    class << self
+      def build(logger_name:, exception:, payload: nil, level: nil)
+        self.new(
+          level || :error,
+          Time.now.utc,
+          logger_name,
+          exception,
+          payload || {},
+          Thread.current.object_id
+        )
+      end
+    end
+
+    def to_h
+      {
+        level:  level,
+        time:   time,
+        msg:    exception.message,
+        logger: logger_name,
+        err:    exception.class.to_s,
+      }.merge!(
+        payload
+      ).merge!(
+        thread:     thread,
+        stacktrace: exception.backtrace,
+      )
+    end
+  end
+end

data/lib/logfoo/exception_handlers/stderr_exception_handler.rb

@@ -1,13 +1,9 @@
-module Logfoo
-
-  class StderrExceptionHanlder
-    def initialize(appender = nil)
-      @appender = appender || IoAppender.new(STDERR)
-    end
-
-    def call(entry)
-      @appender.call entry
-    end
+module Logfoo ; class StderrExceptionHanlder
+  def initialize(appender = nil)
+    @appender = appender || IoAppender.new(STDERR)
   end
 
-end
+  def call(entry)
+    @appender.call entry
+  end
+end ; end

data/lib/logfoo/formatters/logfmt_formatter.rb

@@ -1,85 +1,83 @@
 require 'time'
 
-module Logfoo
-  class LogfmtFormatter
+module Logfoo ; class LogfmtFormatter
 
-    UNESCAPED_STRING = /\A[\w\.\-\+\%\,\:\;\/]*\z/i.freeze
-    STACKTRACE_RE    = /^(.+?):(\d+):in `(.+)'$/.freeze
-    IGNORED_KEYS     = [:time]
-    FLOAT_FORMAT     = '%0.4f'.freeze
+  UNESCAPED_STRING = /\A[\w\.\-\+\%\,\:\;\/]*\z/i.freeze
+  STACKTRACE_RE    = /^(.+?):(\d+):in `(.+)'$/.freeze
+  IGNORED_KEYS     = [:time]
+  FLOAT_FORMAT     = '%0.4f'.freeze
 
-    def call(entry)
-      case entry
-      when ExceptionEntry, Entry
-        format_entry(entry)
-      else
-        "#{remove_nl entry.to_s}\n"
-      end
+  def call(line)
+    case line
+    when ErrLine, LogLine
+      format_line(line)
+    else
+      "#{remove_nl entry.to_s}\n"
     end
+  end
 
-    private
+  private
 
-      def remove_nl(s)
-        s.tr("\n", ' ')
-      end
+  def remove_nl(s)
+    s.tr("\n", ' ')
+  end
 
-      def format_entry(entry)
-        "#{remove_nl format_hash(entry.to_h)}\n"
-      end
+  def format_line(line)
+    "#{remove_nl format_hash(line.to_h)}\n"
+  end
 
-      def format_hash(attrs)
-        attrs.inject([]) do |ac, (k,v)|
-          if !IGNORED_KEYS.include?(k) && !(v == nil || v == "")
-            new_value = sanitize(k, v)
-            ac << "#{k}=#{new_value}"
-          end
-          ac
-        end.join(" ")
+  def format_hash(attrs)
+    attrs.inject([]) do |ac, (k,v)|
+      if !IGNORED_KEYS.include?(k) && !(v == nil || v == "")
+        new_value = sanitize(k, v)
+        ac << "#{k}=#{new_value}"
       end
+      ac
+    end.join(" ")
+  end
 
-      def format_stacktrace(stack)
-        stack =
-          stack.inject([]) do |ac, line|
-            if line.match(STACKTRACE_RE)
-              ac.push "[#{$1}:#{$2}:#{$3}]"
-            end
-            ac
-          end
-        if stack.any?
-          "\"#{stack.join("")}\""
+  def format_stacktrace(stack)
+    stack =
+      stack.inject([]) do |ac, line|
+        if line.match(STACKTRACE_RE)
+          ac.push "[#{$1}:#{$2}:#{$3}]"
         end
+        ac
       end
+    if stack.any?
+      "\"#{stack.join("")}\""
+    end
+  end
 
-      def sanitize(k, v)
-        case v
-        when ::Array
-          if k == :stacktrace
-            format_stacktrace(v)
-            #quote v.map{|i| i.to_s }.join(",")
-          else
-            may_quote v.map{|i| i.to_s }.join(",")
-          end
-        when ::Integer, ::Symbol
-          v.to_s
-        when ::Float
-          FLOAT_FORMAT % v
-        when ::TrueClass
-          :t
-        when ::FalseClass
-          :f
-        when ::Time
-          v.utc.iso8601
-        else
-          may_quote v.to_s
-        end
+  def sanitize(k, v)
+    case v
+    when ::Array
+      if k == :stacktrace
+        format_stacktrace(v)
+      else
+        maybe_quote v.map{|i| i.to_s }.join(",")
       end
+    when ::Integer, ::Symbol
+      v.to_s
+    when ::Float
+      FLOAT_FORMAT % v
+    when ::TrueClass
+      :t
+    when ::FalseClass
+      :f
+    when ::Time
+      v.utc.iso8601
+    else
+      maybe_quote v.to_s
+    end
+  end
 
-      def quote(s)
-        s.inspect
-      end
+  def quote(s)
+    s.inspect
+  end
 
-      def may_quote(s)
-        s =~ UNESCAPED_STRING ? s : quote(s)
-      end
+  def maybe_quote(s)
+    s =~ UNESCAPED_STRING ? s : quote(s)
   end
-end
+
+end ; end

data/lib/logfoo/formatters/simple_formatter.rb

@@ -1,45 +1,43 @@
-module Logfoo
-  class SimpleFormatter < LogfmtFormatter
+module Logfoo ; class SimpleFormatter < LogfmtFormatter
 
-    FORMAT           = "[%5s]: %s -%s%s".freeze
-    BACKTRACE_LINE   = "\t%s\n".freeze
-    EXCEPTION_LINE   = "%s: %s\n".freeze
+  FORMAT           = "[%5s]: %s -%s%s".freeze
+  BACKTRACE_LINE   = "\t%s\n".freeze
+  EXCEPTION_LINE   = "%s: %s\n".freeze
 
-    private
+  private
 
-      def format_entry(entry)
-        attrs = entry.to_h
-        attrs.delete(:backtrace)
-        str = []
-        str << "#{remove_nl format_hash(entry.to_h)}\n"
-        if entry.is_a?(ExceptionEntry)
-          str << format_exception(entry)
-        end
-        str.join("")
-      end
+  def format_line(line)
+    attrs = line.to_h
+    attrs.delete(:backtrace)
+    str = []
+    str << "#{remove_nl format_hash(line.to_h)}\n"
+    if entry.is_a?(ErrLine)
+      str << format_exception(line)
+    end
+    str.join("")
+  end
 
-      def format_exception(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
+  def format_exception(line)
+    values = []
+    values << (EXCEPTION_LINE % [line.exception.class, line.exception.message])
+    if line.exception.backtrace.is_a?(Array)
+      values << line.exception.backtrace.map{|l| BACKTRACE_LINE % l }.join
+    end
+    values.join
+  end
 
-      def format_hash(attrs)
-        level   = attrs.delete(:level)
-        message = attrs.delete(:msg)
-        logger  = attrs.delete(:logger)
+  def format_hash(attrs)
+    level   = attrs.delete(:level)
+    message = attrs.delete(:msg)
+    logger  = attrs.delete(:logger)
 
-        IGNORED_KEYS.each do |f|
-          attrs.delete(f)
-        end
+    IGNORED_KEYS.each do |f|
+      attrs.delete(f)
+    end
 
-        payload = super(attrs)
-        payload = payload.empty? ? "" : " [#{payload}]"
-        message = message.to_s.empty? ? "" : " #{message}"
-        FORMAT % [level.upcase, logger, message, payload]
-      end
+    payload = super(attrs)
+    payload = payload.empty? ? "" : " [#{payload}]"
+    message = message.to_s.empty? ? "" : " #{message}"
+    FORMAT % [level.upcase, logger, message, payload]
   end
-end
+end ; end

data/lib/logfoo/integrations/hutch.rb

@@ -1,33 +1,32 @@
 require 'hutch'
 
-module Logfoo ; module Hutch
-  class ErrorHandler
-    attr_reader :bunny_log, :hutch_log
+module Logfoo ; module Hutch ; class ErrorHandler
+  attr_reader :bunny_log, :hutch_log
 
-    class << self
-      attr_accessor :handler
-    end
+  class << self
+    attr_accessor :handler
+  end
 
-    ID = 'Hutch'.freeze
+  ID = 'Hutch'.freeze
 
-    def initialize
-      @hutch_log = Logfoo.get_logger(ID)
-      @bunny_log = Logfoo.get_logger('Bunny')
-      @bunny_log.level = Logfoo::WARN
-    end
+  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 = ExceptionEntry.build(
-        ID,
-        ex,
-        payload:    payload,
-        consumer:   consumer,
-        message_id: message_id
+  def handle(message_id, payload, consumer, ex)
+    line = ErrLine.build(
+      logger_name: ID,
+      exception:   ex,
+      payload:     (payload || {}).merge!(
+        consumer:    consumer,
+        message_id:  message_id
       )
-      App.instance.append(entry)
-    end
+    )
+    App.instance.append(line)
   end
-end ; end
+end ; end ; end
 
 Logfoo::Hutch::ErrorHandler.handler = Logfoo::Hutch::ErrorHandler.new
 

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

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

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

@@ -1,52 +1,48 @@
-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
+module Logfoo ; module 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 ; end ; end
 

data/lib/logfoo/measure.rb

@@ -0,0 +1,19 @@
+module Logfoo ; Measure = Struct.new(:source) do
+  def benchmark(level, message, payload, block)
+    payload    ||= {}
+    time_start   = Time.now.to_f
+    reply        = source._call_log_fn(block, payload)
+
+    payload.merge!(duration: Time.now.to_f - time_start)
+    source.public_send(level, message, payload)
+    reply
+  end
+
+  Logfoo::LEVELS.each do |lv|
+    level_id = lv.downcase.to_sym
+
+    define_method level_id do |message, payload = nil, &block|
+      benchmark(level_id, message, payload || {}, block)
+    end
+  end
+end ; end

data/lib/logfoo/mixin.rb

@@ -1,16 +1,14 @@
-module Logfoo
-  module Mixin
-    def self.included(base)
-      base.extend ClassMethods
-      base.log = Logfoo.get_logger(base.name)
-    end
+module Logfoo ; module Mixin
+  def self.included(base)
+    base.extend ClassMethods
+    base.log = Logfoo.get_logger(base.name)
+  end
 
-    module ClassMethods
-      attr_accessor :log
-    end
+  module ClassMethods
+    attr_accessor :log
+  end
 
-    def log
-      self.class.log
-    end
+  def log
+    self.class.log
   end
-end
+end ; end

data/lib/logfoo/version.rb

@@ -1,3 +1,3 @@
 module Logfoo
-  VERSION = '0.1.5'
+  VERSION = '0.2.0'
 end

data/lib/logfoo.rb

@@ -26,11 +26,12 @@ module Logfoo
 end
 
 %w{
-  entry
+  entries
   formatters/logfmt_formatter
   formatters/simple_formatter
   appenders/io_appender
   exception_handlers/stderr_exception_handler
+  measure
   app
   context
   mixin

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logfoo
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.2.0
 platform: ruby
 authors:
 - Dmitry Galinsky
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-05-11 00:00:00.000000000 Z
+date: 2016-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -99,7 +99,7 @@ files:
 - lib/logfoo/app.rb
 - lib/logfoo/appenders/io_appender.rb
 - lib/logfoo/context.rb
-- lib/logfoo/entry.rb
+- lib/logfoo/entries.rb
 - lib/logfoo/exception_handlers/stderr_exception_handler.rb
 - lib/logfoo/formatters/logfmt_formatter.rb
 - lib/logfoo/formatters/simple_formatter.rb
@@ -107,6 +107,7 @@ files:
 - lib/logfoo/integrations/rack.rb
 - lib/logfoo/integrations/rack/err.rb
 - lib/logfoo/integrations/rack/log.rb
+- lib/logfoo/measure.rb
 - lib/logfoo/mixin.rb
 - lib/logfoo/version.rb
 - logfoo.gemspec

data/lib/logfoo/entry.rb

@@ -1,46 +0,0 @@
-module Logfoo
-  Entry = Struct.new(:level, :time, :logger_name, :message, :payload, :thread) do
-    def to_h
-      {
-        level:   level   || :info,
-        time:    time    || Time.now,
-        msg:     message,
-        logger:  logger_name,
-      }.merge!(
-        payload || {}
-      ).merge!(
-        thread:  thread
-      )
-    end
-  end
-
-  ExceptionEntry = Struct.new(:level, :time, :logger_name, :exception, :payload, :thread) do
-    class << self
-      def build(logger_name, ex, payload = nil, options = {})
-        self.new(
-          options[:level],
-          Time.now,
-          logger_name,
-          ex,
-          payload,
-          Thread.current.object_id
-        )
-      end
-    end
-
-    def to_h
-      {
-        level:  level || :error,
-        time:   time  || Time.now,
-        msg:    exception.message,
-        logger: logger_name,
-        err:    exception.class.to_s,
-      }.merge!(
-        payload || {}
-      ).merge!(
-        thread:     thread,
-        stacktrace: exception.backtrace,
-      )
-    end
-  end
-end