logger_facade 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0180ea9d2371adfb7dc9745b2b5c550fada71357
-  data.tar.gz: 9969640e45a3c0f9f1be24f52834c9c5f1a37b83
+  metadata.gz: a44006ba93de9dceaa753368eb3b452fe733e416
+  data.tar.gz: 654b4861ab41420d47ed09e825af6672c7a8683b
 SHA512:
-  metadata.gz: 20a421d2ff5f652551b050047652034c374974eca980c68787815f4910acefb7d79032d033353ab64e1dbadeb80612e044c259fdb4da0a3c879fae971df7f8cc
-  data.tar.gz: f15e7d566a1b471521260c54d4555a1a82ff6b48d9cbfce7c6aceee9112ed7e30ccae0e5921911a8963d32aa452365d6dbe6ef18ac31b0c6c04ba8afeaa5c51a
+  metadata.gz: 57d9fa7a05c8819f5976d0b38296d8efa1a5a4e55a2989339ecb03ec0af7166ebb72ab3d6638350d27dbb57db693167f8b20cb7509a9ea7195bde31256aaea1c
+  data.tar.gz: da2c70344b93d61fc57d6d84804a959f56aa6977032ab149e8edc2aa003daa13b815fa5078c79fc66a9344194fe0477c8c6269649158fec4a89b20d66d079942

data/.rspec

@@ -1 +1 @@
--f doc --color
+-f doc --color --require spec_helper

data/Gemfile.lock

@@ -1,55 +1,60 @@
 PATH
   remote: .
   specs:
-    logger_facade (0.2.0)
+    logger_facade (0.3.0)
       airbrake (~> 4.0)
       hashie (~> 3.2)
       sucker_punch (~> 1.1)
+      yajl-ruby (~> 1.2)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    airbrake (4.0.0)
+    airbrake (4.1.0)
       builder
       multi_json
     builder (3.2.2)
-    bump (0.5.0)
-    celluloid (0.15.2)
-      timers (~> 1.1.0)
-    codeclimate-test-reporter (0.3.0)
+    bump (0.5.1)
+    celluloid (0.16.0)
+      timers (~> 4.0.0)
+    codeclimate-test-reporter (0.4.4)
       simplecov (>= 0.7.1, < 1.0.0)
     coderay (1.1.0)
     diff-lcs (1.2.5)
     docile (1.1.5)
-    hashie (3.2.0)
+    hashie (3.3.2)
+    hitimes (1.2.2)
     method_source (0.8.2)
     multi_json (1.10.1)
-    pry (0.10.0)
+    pry (0.10.1)
       coderay (~> 1.1.0)
       method_source (~> 0.8.1)
       slop (~> 3.4)
-    rake (10.3.2)
-    rspec (3.0.0)
-      rspec-core (~> 3.0.0)
-      rspec-expectations (~> 3.0.0)
-      rspec-mocks (~> 3.0.0)
-    rspec-core (3.0.3)
-      rspec-support (~> 3.0.0)
-    rspec-expectations (3.0.3)
+    rack (1.6.0)
+    rake (10.4.2)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.7)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.2)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.0.0)
-    rspec-mocks (3.0.3)
-      rspec-support (~> 3.0.0)
-    rspec-support (3.0.3)
-    simplecov (0.9.0)
+      rspec-support (~> 3.1.0)
+    rspec-mocks (3.1.3)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.2)
+    simplecov (0.9.1)
       docile (~> 1.1.0)
-      multi_json
+      multi_json (~> 1.0)
       simplecov-html (~> 0.8.0)
     simplecov-html (0.8.0)
     slop (3.6.0)
-    sucker_punch (1.1)
-      celluloid (~> 0.15.2)
-    timers (1.1.0)
+    sucker_punch (1.3.2)
+      celluloid (~> 0.16.0)
+    timers (4.0.1)
+      hitimes
+    yajl-ruby (1.2.1)
 
 PLATFORMS
   ruby
@@ -60,6 +65,7 @@ DEPENDENCIES
   codeclimate-test-reporter (~> 0.3)
   logger_facade!
   pry (~> 0.10)
+  rack (~> 1.6)
   rake (~> 10.3)
   rspec (~> 3.0)
   simplecov (~> 0.9)

data/README.md

@@ -39,13 +39,6 @@ Set up plugins
 ```ruby
 require 'logger_facade'
 
-# this is default config for Console plugin
-config = {
-  level: :info,
-  time_format: '%y-%M-%d %H:%M:%S',
-  message_format: '%time | %level | %logger - %msg'
-}
-
 # configuration is optional in console plugin
 plugin = LoggerFacade::Plugins::Console.new(config);
 
@@ -65,10 +58,52 @@ log.error(Exception.new("some caught exception"))
 
 **NOTE**: Console plugin uses check [strftime](http://www.ruby-doc.org/core-2.1.2/Time.html#method-i-strftime) formats.
 
+### With Sinatra
+
+```ruby
+require 'logger_facade'
+require 'logger_facade/middleware/rack'
+
+plugin = LoggerFacade::Plugins::Console.new({ level: Settings.logging.console.level })
+LoggerFacade::Manager.use(plugin)
+
+set :logging, nil
+use LoggerFacade::Middleware::Rack
+```
+
+### Injecting log with LoggerFacade::Loggable module
+
+```ruby
+class AwesomeLog
+  include LoggerFacade::Loggable
+
+  def action
+    log.debug("This will allow you to log into Logger with class name, here is 'AwesomeLog'")
+  end
+
+end
+
+# equivalent to
+
+class AwesomeLog
+
+  def action
+    log.debug("This will allow you to log into Logger with class name, here is 'AwesomeLog'")
+  end
+
+  private
+
+  def log
+    @log ||= LoggerFacade::Manager.get_logger("AwesomeLog")
+  end
+
+end
+```
+
 ## Available plugins
-* Console
-* Airbrake (Will be developed soon)
-* Elasticsearch (Will be developed soon)
+* [Console](#loggerfacadepluginsconsole)
+* [Airbrake](#loggerfacadepluginsairbrake)
+* [Logstash](loggerfacadepluginslogstash)
 
 ** Do you need some other plugin?**
 
@@ -91,30 +126,96 @@ log = LoggerFacade::Manager.getLogger("Log Name")
 
 ```ruby
 log.isDebug() # return if in debug or trace level
+metadata = { metadata: "some more context" }
+# log.trace(message, metadata = {})
 log.trace("trace something")
+# log.debug(message, metadata = {})
 log.debug("debug something")
+# log.info(message, metadata = {})
 log.info("info something")
+# log.warn(message, metadata = {})
 log.warn("warn something")
-log.error("error something")
+# log.error(message, metadata = {})
+log.error("error something", metadata)
 log.error(Exception.new('some caught exception'))
 ```
 
-## LoggerFacade::Plugins
+## Plugins available
+
+### LoggerFacade::Plugins::Console
+
+```ruby
+# this is default config for Console plugin
+config = {
+  level: :info,
+  time_format: '%y-%M-%d %H:%M:%S',
+  message_format: '%time | %level | %logger - %msg'
+}
+
+# configuration is optional in console plugin
+plugin = LoggerFacade::Plugins::Console.new(config);
+LoggerFacade::Manager.use(plugin)
+```
 
-The plugins must follow this contract:
+### LoggerFacade::Plugins::Airbrake
 
+```ruby
+env = 'production'
+plugin = LoggerFacade::Plugins::Airbrake.new(env)
+plugin.configure do |config|
+  config.api_key = "airbrake.api_key"
+  config.host = "airbrake.host"
+  config.port = "airbrake.port"
+  config.secure = config.port == 443
+end
+LoggerFacade::Manager.use(plugin)
 ```
-# plugin name
-#name
-
-#isDebug
-#trace
-#debug
-#info
-#warn
-#error
+
+### LoggerFacade::Plugins::Logstash
+
+```ruby
+# this is default config for Console plugin
+config = { level: :debug }
+
+# configuration is optional in Logstash plugin
+plugin = LoggerFacade::Plugins::Logstash.new(config);
+LoggerFacade::Manager.use(plugin)
+
+
+# by default logrotation is disabled and you should consider using a proper tool such logrotate.
+# but you can use some Logger (from stdlib) options.
+config = {
+  level: :debug
+  device: {
+    shift_age: 'daily', # (optional) daily/weekly/monthly
+    shift_size: 1024000 # (optional) bytes
+  }
+}
+
 ```
 
+## LoggerFacade::Plugins
+
+If you wanna use a custom plugin you just need to use an object that responds to the following contract:
+
+```ruby
+# the plugin name
+plugin.name
+# the plugin configuration
+plugin.config
+# the plugin level
+plugin.level
+
+def isDebug() # return if in debug or trace level
+def trace(logger, message, metadata: {})
+def debug(logger, message, metadata: {})
+def info(logger, message, metadata: {})
+def warn(logger, message, metadata: {})
+def error(logger, message, metadata: {})
+def error(logger, exception, metadata: {})
+```
+
+
 ## Contributing
 
 1. Fork it
@@ -126,18 +227,19 @@ The plugins must follow this contract:
 ## Bump versioning
 
 We use [bump gem](https://github.com/gregorym/bump) to control gem versioning.
+Use --tag to generate commit and tag for each version.
 
 Bump Patch version
 
-    $ bump patch
+    $ bump patch --tag
 
 Bump Minor version
 
-    $ bump minor
+    $ bump minor --tag
 
 Bump Major version
 
-    $ bump major
+    $ bump major --tag
 
 ## Running Specs
 

data/lib/logger_facade/log.rb

@@ -13,31 +13,33 @@ module LoggerFacade
       plugins.select { |p| p.is_debug }.size > 0
     end
 
-    def trace(message)
-      log(:trace, message)
+    def trace(message, metadata = {})
+      log(:trace, message, metadata)
     end
 
-    def debug(message)
-      log(:debug, message)
+    def debug(message, metadata = {})
+      log(:debug, message, metadata)
     end
 
-    def info(message)
-      log(:info, message)
+    def info(message, metadata = {})
+      log(:info, message, metadata)
     end
 
-    def warn(message)
-      log(:warn, message)
+    def warn(message, metadata = {})
+      log(:warn, message, metadata)
     end
 
-    def error(message)
-      log(:error, message)
+    def error(message, metadata = {})
+      log(:error, message, metadata)
     end
 
     private
 
-    def log(level, message)
+    def log(level, message, metadata)
+      metadata[:timestamp] = Time.now.utc
+      metadata[:pid] = Process.pid
       plugins.each do |plugin|
-        plugin.send(level, name, message)
+        plugin.send(level, name, message, metadata: metadata)
       end
     end
 

data/lib/logger_facade/middleware/rack.rb

@@ -0,0 +1,43 @@
+module LoggerFacade::Middleware
+  class Rack < Rack::CommonLogger
+    def initialize(app, logger=nil)
+      log = LoggerFacade::Manager.get_logger("RackLogger")
+      @format = '%s "%s %s" %d %s %0.4f'
+      super(app, log)
+    end
+
+    private
+
+    def log(env, status, header, began_at)
+      metadata = get_metadata(env, status, header, began_at)
+
+      msg = @format % [
+        metadata["clientip"] || "-",
+        metadata["verb"],
+        metadata["request"],
+        metadata["response"].to_s[0..3],
+        metadata["bytes"],
+        metadata["request_time"] ]
+
+      @logger.info(msg, metadata)
+    end
+
+    def get_metadata(env, status, header, began_at)
+      length = extract_content_length(header)
+      qs = env["QUERY_STRING"].empty? ? "" : "?#{env["QUERY_STRING"]}"
+      {
+        'clientip'     => env['HTTP_X_FORWARDED_FOR'] || env["REMOTE_ADDR"],
+        'verb'        => env["REQUEST_METHOD"],
+        'request'          => "#{env["PATH_INFO"]}#{qs}",
+        'http_version'  => env["HTTP_VERSION"],
+        'response'        => status.to_s,
+        'bytes'          => (length || "").to_i,
+        'referrer'          => env["HTTP_REFERER"],
+        'agent'         => env['HTTP_USER_AGENT'],
+        'request_time' => Time.now - began_at,
+        'request_full_url' => env['REQUEST_URI']
+      }
+    end
+
+  end
+end

data/lib/logger_facade/plugins.rb

@@ -1,2 +1,4 @@
+require_relative 'plugins/base'
 require_relative 'plugins/console'
 require_relative 'plugins/airbrake'
+require_relative 'plugins/logstash'

data/lib/logger_facade/plugins/base.rb

@@ -0,0 +1,59 @@
+module LoggerFacade::Plugins
+
+  class Base
+
+    attr_reader :config, :level, :name
+
+    def initialize(name, config = nil)
+      @config = Hashie::Mash.new(config)
+      @level = (@config.level || :debug).to_sym
+      @name = name
+    end
+
+    def is_debug
+      is_level_active(:debug)
+    end
+
+    def trace(logger, message, metadata: {})
+      log(:trace, message, logger, metadata)
+    end
+
+    def debug(logger, message, metadata: {})
+      log(:debug, message, logger, metadata)
+    end
+
+    def info(logger, message, metadata: {})
+      log(:info, message, logger, metadata)
+    end
+
+    def warn(logger, message, metadata: {})
+      log(:warn, message, logger, metadata)
+    end
+
+    def error(logger, message, metadata: {})
+      log(:error, message, logger, metadata)
+    end
+
+    protected
+
+    def log(severity, message, logger, metadata)
+      # do nothing by default
+    end
+
+    def levels
+      {
+        trace: 0,
+        debug: 1,
+        info:  2,
+        warn:  3,
+        error: 4
+      }
+    end
+
+    def is_level_active(log_level)
+      levels[log_level] >= levels[level]
+    end
+
+  end
+
+end

data/lib/logger_facade/plugins/console.rb

@@ -2,9 +2,7 @@ require 'hashie'
 
 module LoggerFacade::Plugins
 
-  class Console
-
-    attr_reader :config, :level, :name
+  class Console < Base
 
     def initialize(config = {})
       defaults = {
@@ -13,73 +11,39 @@ module LoggerFacade::Plugins
         message_format: '%time | %level | %logger - %msg'
       }
       config = defaults.merge(config)
-
-      @config = Hashie::Mash.new(config)
-      @level = @config.level.to_sym
-      @name = "LoggerFacade::Plugins::Console"
-    end
-
-    def is_debug
-      is_level_active(:debug)
-    end
-
-    def trace(logger, message)
-      log(:trace, message, logger)
+      super("LoggerFacade::Plugins::Console", config)
     end
 
-    def debug(logger, message)
-      log(:debug, message, logger)
-    end
+    protected
 
-    def info(logger, message)
-      log(:info, message, logger)
-    end
-
-    def warn(logger, message)
-      log(:warn, message, logger)
-    end
+    def log(log_level, message, logger, metadata)
+      return unless is_level_active(log_level)
 
-    def error(logger, message)
-      log(:error, message, logger)
+      write message(log_level, message, logger, metadata)
     end
 
     private
 
-    def levels
-      {
-        trace: 0,
-        debug: 1,
-        info:  2,
-        warn:  3,
-        error: 4
-      }
-    end
-
-    def is_level_active(log_level)
-      levels[log_level] >= levels[level]
-    end
+    def message(level, msg, logger, metadata)
+      msg = log_exception(msg) if msg.is_a? Exception
 
-    def message(level, msg, logger)
-      outputMsg = msg
+      timestamp = metadata[:timestamp] || Time.now.utc
+      pid = metadata[:pid] || Process.pid
 
-      if msg.is_a? Exception
-        outputMsg = "#{msg.message}\n#{(msg.backtrace || []).join("\n")}"
-      end
-
-      formatedMessage = config.message_format
+      config.message_format
         .gsub('%logger', logger.upcase)
-        .gsub('%time', Time.now.utc.strftime(config.time_format))
+        .gsub('%time', timestamp.strftime(config.time_format))
         .gsub('%level', level.to_s.upcase)
-        .gsub('%pid', Process.pid.to_s)
-        .gsub('%msg', outputMsg)
-
-      return formatedMessage;
+        .gsub('%pid', pid.to_s)
+        .gsub('%msg', msg)
     end
 
-    def log(log_level, message, logger)
-      return unless is_level_active(log_level)
+    def log_exception(msg)
+      "#{msg.message}\n#{(msg.backtrace || []).join("\n")}"
+    end
 
-      Kernel.puts message(log_level, message, logger)
+    def write(message)
+      Kernel.puts message
     end
 
   end

data/lib/logger_facade/plugins/logstash.rb

@@ -0,0 +1,64 @@
+require 'logger'
+require 'yajl'
+
+module LoggerFacade::Plugins
+  class Logstash < Base
+
+    def initialize(configuration = {})
+      super("LoggerFacade::Plugins::Logstash", configuration)
+
+      fail "Invalid configuration filename: #{config.filename}" unless config.filename
+
+      @logdevice = if config["device"]
+        shift_age = config.device["shift_age"]
+        shift_size = config.device["shift_size"]
+        LogDeviceWithRotation.new(config.filename, shift_age, shift_size)
+      else
+        LogDeviceWithoutRotation.new(config.filename)
+      end
+    end
+
+    private
+
+    attr_reader :logdevice
+
+    def log(severity, message, logger, metadata)
+      return unless is_level_active(severity)
+      return unless logdevice
+
+      ts = metadata.delete :timestamp
+      ts ||= Time.now.utc
+      metadata[:severity] = severity
+      metadata[:logger] = logger
+      metadata[:message] = message
+      metadata[:backtrace] = message.backtrace if message.is_a? Exception
+
+      json = {
+       '@timestamp' => ts.iso8601,
+       '@fields'    => metadata
+      }
+      
+      @logdevice.write("#{Yajl::Encoder.encode(json)}\n")
+    end
+
+    class LogDeviceWithRotation < ::Logger::LogDevice
+
+      private
+
+      # overrides base.add_log_header to disable log header
+      def add_log_header(file)
+      end
+    end
+
+    class LogDeviceWithoutRotation < LogDeviceWithRotation
+
+      # overrides base.write to disable log shifting
+      def write(message)
+        @mutex.synchronize do
+          @dev.write(message)
+        end
+      end
+    end
+
+  end
+end

data/lib/logger_facade/version.rb

@@ -1,3 +1,3 @@
 module LoggerFacade
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

data/logger_facade.gemspec

@@ -29,9 +29,12 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'simplecov', '~> 0.9'
   spec.add_development_dependency 'codeclimate-test-reporter', '~> 0.3'
   spec.add_development_dependency 'bump', '~> 0.5'
+  spec.add_development_dependency 'rack', '~> 1.6'
 
   spec.add_dependency 'hashie', '~> 3.2'
   spec.add_dependency 'airbrake', '~> 4.0'
   # sucker punch is used to use airbrake async
   spec.add_dependency 'sucker_punch', '~> 1.1'
+  # used by logstash plugin, for better performance
+  spec.add_dependency 'yajl-ruby', '~> 1.2'
 end

data/spec/spec_helper.rb

@@ -23,3 +23,31 @@ RSpec.configure do |c|
     }
   end
 end
+
+module TimeTestHelper
+  def with_mock_time(t = 0)
+    mc = class <<Time; self; end
+    mc.send :alias_method, :old_now, :now
+    mc.send :define_method, :now do
+      at(t)
+    end
+    yield
+  ensure
+    mc.send :alias_method, :now, :old_now
+  end
+end
+
+module LevelTestHelper
+  def next_level(lev)
+    levels = {
+      trace: 0,
+      debug: 1,
+      info:  2,
+      warn:  3,
+      error: 4
+    }
+
+    val = levels[lev.to_sym]
+    levels.select { |k,v| v > val }.keys.first
+  end
+end

data/spec/unit/log_spec.rb

@@ -41,13 +41,57 @@ describe LoggerFacade::Log do
   %w(trace debug info warn error).each do |level|
 
     describe("##{level}") do
+      let(:time) { Time.new(1983, 01, 25, 13, 10, 01, '+00:00') }
+      let(:pid) { 0 }
 
       it("calls the plugin in #{level} level") do
         message = "call with message"
-        expect(plugin).to receive(level.to_sym).with(subject.name, message)
+        expect(plugin).to receive(level.to_sym).with(subject.name, message, anything)
         subject.send(level.to_sym, message)
       end
 
+      it("calls the plugin with metadata dictionary when not present") do
+        message = "call with message"
+        metadata = {}
+        expect(plugin).to receive(level.to_sym)
+          .with(subject.name, message,
+            hash_including(metadata: hash_including(:timestamp, :pid)))
+        subject.send(level.to_sym, message)
+      end
+
+      it("appends timestamp to metadata") do
+        allow(Time).to receive(:now) { time }
+        message = "call with message"
+        metadata = {}
+        expect(plugin).to receive(level.to_sym)
+          .with(subject.name, message,
+            hash_including(metadata: hash_including(timestamp: time))
+          )
+        subject.send(level.to_sym, message, metadata)
+      end
+
+      it("appends timestamp to metadata") do
+        allow(Time).to receive(:now) { time }
+        message = "call with message"
+        metadata = {}
+        expect(plugin).to receive(level.to_sym)
+          .with(subject.name, message,
+            hash_including(metadata: hash_including(timestamp: time))
+          )
+        subject.send(level.to_sym, message, metadata)
+      end
+
+      it("appends pid to metadata") do
+        allow(Process).to receive(:pid) { pid }
+        message = "call with message"
+        metadata = {}
+        expect(plugin).to receive(level.to_sym)
+          .with(subject.name, message,
+            hash_including(metadata: hash_including(pid: pid))
+          )
+        subject.send(level.to_sym, message, metadata)
+      end
+
     end
 
   end

data/spec/unit/middleware/rack_spec.rb

@@ -0,0 +1,107 @@
+require 'rack/commonlogger'
+require 'rack/lint'
+require 'rack/mock'
+require 'logger_facade'
+require 'logger_facade/middleware/rack'
+
+describe LoggerFacade::Middleware::Rack do
+  include TimeTestHelper
+  let(:regex) do
+    /(-) "(\w+) \/(\w+)\?(q=\w+)" (\d{3}) (\d+) ([\d\.]+)/
+  end
+  let(:logger) { double('logger') }
+  let(:obj) { "foobar" }
+  let(:length) { obj.size }
+  let(:app) do
+    Rack::Lint.new lambda { |env|
+      [200,
+       {"Content-Type" => "text/html", "Content-Length" => length.to_s},
+       [obj]]}
+  end
+
+  before do
+    expect(LoggerFacade::Manager).to receive(:get_logger){ logger }
+  end
+
+  it "logs to logger facade instance" do
+    expect(logger).to receive(:info)#.with('- "GET /" 200 6 0.0007')
+    res = Rack::MockRequest.new(described_class.new(app)).get("/")
+  end
+
+  it "log in the specified log format" do
+    expect(logger).to receive(:info) do |message|
+      md = regex.match(message)
+      expect(md).not_to be_nil
+      ip, method, path, qs, status, size, duration = *md.captures
+      expect(ip).to eq("-")
+      expect(method).to eq("GET")
+      expect(path).to eq("path")
+      expect(qs).to eq("q=true")
+      expect(status).to eq("200")
+      expect(size).to eq(length.to_s)
+      expect(duration.to_f).to eq(0)
+    end
+    with_mock_time do
+      Rack::MockRequest.new(described_class.new(app)).get("/path?q=true")
+    end
+  end
+  
+  context 'with proper metadata' do
+
+    after do
+      with_mock_time do
+        Rack::MockRequest.new(described_class.new(app)).get("/path?q=true")
+      end
+    end
+
+    it "log clientip as metadata" do
+      expect(logger).to receive(:info)
+        .with(anything, hash_including("clientip"))
+    end
+
+    it "log verb as metadata" do
+      expect(logger).to receive(:info)
+        .with(anything, hash_including("verb" => "GET"))
+    end
+
+    it "log request as metadata" do
+      expect(logger).to receive(:info)
+        .with(anything, hash_including("request" => "/path?q=true"))
+    end
+
+    it "log http_version as metadata" do
+      expect(logger).to receive(:info)
+        .with(anything, hash_including("http_version" => nil))
+    end
+
+    it "log response as metadata" do
+      expect(logger).to receive(:info)
+        .with(anything, hash_including("response" => "200"))
+    end
+
+    it "log bytes as metadata" do
+      expect(logger).to receive(:info)
+        .with(anything, hash_including("bytes" => length))
+    end
+
+    it "log referrer as metadata" do
+      expect(logger).to receive(:info)
+        .with(anything, hash_including("referrer" => nil))
+    end
+
+    it "log agent as metadata" do
+      expect(logger).to receive(:info)
+        .with(anything, hash_including("agent" => nil))
+    end
+
+    it "log request_time as metadata" do
+      expect(logger).to receive(:info)
+        .with(anything, hash_including("request_time" => 0.0))
+    end
+
+    it "log request_full_url as metadata" do
+      expect(logger).to receive(:info)
+        .with(anything, hash_including("request_full_url" => nil))
+    end
+  end
+end

data/spec/unit/plugins/console_spec.rb

@@ -1,10 +1,12 @@
 require 'spec_helper'
 
 describe LoggerFacade::Plugins::Console do
+  include LevelTestHelper
 
   subject { described_class.new }
 
   let(:time) { Time.new(1983, 01, 25, 13, 10, 01, '+00:00') }
+  let(:metadata){ { timestamp: time, pid: 100 } }
 
   before :each do
     allow(Time).to receive(:now) { time }
@@ -23,19 +25,6 @@ describe LoggerFacade::Plugins::Console do
 
   end
 
-  def next_level(lev)
-    levels = {
-      trace: 0,
-      debug: 1,
-      info:  2,
-      warn:  3,
-      error: 4
-    }
-
-    val = levels[lev.to_sym]
-    levels.select { |k,v| v > val }.keys.first
-  end
-
   %w(trace debug info warn error).each do |level|
 
     context("logging in #{level} level") do

data/spec/unit/plugins/logstash_spec.rb

@@ -0,0 +1,207 @@
+require 'json'
+
+describe LoggerFacade::Plugins::Logstash do
+  include LevelTestHelper
+
+  subject { described_class.new }
+
+  let(:filename) { './test.log' }
+  let(:config) { { filename: filename } }
+  let(:time) { Time.new(1983, 01, 25, 13, 10, 01, '+00:00') }
+  let(:metadata){ { timestamp: time, pid: 100 } }
+  let(:file) { double('file') }
+
+  before :each do
+    allow(Time).to receive(:now) { time }
+    allow_any_instance_of(Object).to receive(:open) { file }
+    allow_any_instance_of(Object).to receive(:sync=)
+  end
+
+  describe("initialize") do
+    it 'defaults to logdevice without rotation' do
+      expect(LoggerFacade::Plugins::Logstash::LogDeviceWithoutRotation)
+        .to receive(:new).with(filename)
+      described_class.new(config)
+    end
+
+    it 'uses ruby Logger config' do
+      age = 'age'
+      size = 1024
+      config[:device] = { shift_age: age, shift_size: size }
+      expect(LoggerFacade::Plugins::Logstash::LogDeviceWithRotation)
+        .to receive(:new).with(filename, age, size)
+      described_class.new(config)
+    end
+
+    it 'raises an error on invalid filename configuration' do
+      expect { described_class.new({}) }.to raise_exception(RuntimeError)
+    end
+  end
+
+  describe('#is_debug') do
+
+    it('returns true when log level lower than info') do
+      subject = described_class.new(config)
+      expect(subject.is_debug).to be true
+    end
+
+    it('returns false when log level higher than debug') do
+      config[:level] = :info
+      subject = described_class.new(config)
+      expect(subject.is_debug).to be false
+    end
+
+  end
+
+  %w(trace debug info warn error).each do |level|
+
+    context("logging in #{level} level") do
+      subject do
+        config[:level] = level.to_sym
+        described_class.new(config)
+      end
+
+      let(:message) { "call with message" }
+      let(:logger) { "name" }
+      let(:severity) { level.to_sym }
+
+      context("when plugin log level lower or equal than #{level}") do
+
+        it("writes to file") do
+          expect(file).to receive(:write)
+          subject.send(severity, logger, message)
+        end
+
+        context 'format' do
+          it("writes a valid json") do
+            expect(file).to receive(:write) do |msg|
+              data = nil
+              expect { data = JSON.parse(msg) }.not_to raise_exception
+              expect(data).to be
+            end
+            subject.send(severity, logger, message)
+          end
+
+          it("ends with line break") do
+            expect(file).to receive(:write) do |msg|
+              expect(msg[-1,1]).to eq("\n")
+            end
+            subject.send(severity, logger, message)
+          end
+
+          context 'timestamp' do
+            # time + 1.month
+            let(:ts) { time + 2592000 }
+            let(:metadata) { { timestamp: ts } }
+
+            it("writes logstash timestamp format") do
+              expect(file).to receive(:write) do |msg|
+                data = JSON.parse(msg)
+                expect(data["@timestamp"]).to eq(time.iso8601)
+              end
+              subject.send(severity, logger, message)
+            end
+
+            it("uses metadata timestamp") do
+              expect(file).to receive(:write) do |msg|
+                data = JSON.parse(msg)
+                expect(data["@timestamp"]).to eq(ts.iso8601)
+              end
+              subject.send(severity, logger, message, metadata: metadata)
+            end
+
+            it("doesn't write field timestamp") do
+              expect(file).to receive(:write) do |msg|
+                data = JSON.parse(msg)["@fields"]
+                expect(data["timestamp"]).to be_nil
+              end
+              subject.send(severity, logger, message, metadata: metadata)
+            end
+          end
+
+          it("writes fields") do
+            expect(file).to receive(:write) do |msg|
+              data = JSON.parse(msg)
+              expect(data["@fields"]).to be
+            end
+            subject.send(severity, logger, message)
+          end
+
+          it("writes severity") do
+            expect(file).to receive(:write) do |msg|
+              data = JSON.parse(msg)["@fields"]
+              expect(data["severity"]).to eq(severity.to_s)
+            end
+            subject.send(severity, logger, message)
+          end
+
+          it("writes logger") do
+            expect(file).to receive(:write) do |msg|
+              data = JSON.parse(msg)["@fields"]
+              expect(data["logger"]).to eq(logger)
+            end
+            subject.send(severity, logger, message)
+          end
+
+          it("writes message") do
+            expect(file).to receive(:write) do |msg|
+              data = JSON.parse(msg)["@fields"]
+              expect(data["message"]).to eq(message)
+            end
+            subject.send(severity, logger, message)
+          end
+
+          it("writes other metadata fields") do
+            metadata = { context: true }
+            expect(file).to receive(:write) do |msg|
+              data = JSON.parse(msg)["@fields"]
+              expect(data["context"]).to eq(true)
+            end
+            subject.send(severity, logger, message, metadata: metadata)
+          end
+
+          context "on excepetion parameter" do
+
+            it('writes the exception message') do
+              error = Exception.new('test log')
+              expect(file).to receive(:write) do |msg|
+                data = JSON.parse(msg)["@fields"]
+                expect(data["message"]).to eq("test log")
+              end
+              subject.send(severity, logger, error)
+            end
+
+            it('writes the exception backtrace') do
+              error = Exception.new('test log')
+              error.set_backtrace "stacktrace"
+              expect(file).to receive(:write) do |msg|
+                data = JSON.parse(msg)["@fields"]
+                expect(data["backtrace"]).to eq(error.backtrace)
+              end
+              subject.send(severity, logger, error)
+            end
+          end
+        end
+
+      end
+
+      unless level == 'error'
+      context("when plugin log level higher than #{level}") do
+        subject do
+          config[:level] = next_level(level)
+          described_class.new(config)
+        end
+
+        it("doesn't write to file") do
+          expect(file).not_to receive(:write)
+          subject.send(level.to_sym, "name", message)
+        end
+
+      end
+      end
+
+    end
+
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logger_facade
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Pedro Januário
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-31 00:00:00.000000000 Z
+date: 2015-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -108,6 +108,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
 - !ruby/object:Gem::Dependency
   name: hashie
   requirement: !ruby/object:Gem::Requirement
@@ -150,6 +164,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: yajl-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
 description: |-
   Simple class library to work as logger facade.
                           This simple logger facade allows you to hook plugins to execute logging.
@@ -172,17 +200,22 @@ files:
 - lib/logger_facade/log.rb
 - lib/logger_facade/loggable.rb
 - lib/logger_facade/manager.rb
+- lib/logger_facade/middleware/rack.rb
 - lib/logger_facade/plugins.rb
 - lib/logger_facade/plugins/airbrake.rb
+- lib/logger_facade/plugins/base.rb
 - lib/logger_facade/plugins/console.rb
+- lib/logger_facade/plugins/logstash.rb
 - lib/logger_facade/version.rb
 - logger_facade.gemspec
 - spec/spec_helper.rb
 - spec/unit/log_spec.rb
 - spec/unit/loggable_spec.rb
 - spec/unit/manager_spec.rb
+- spec/unit/middleware/rack_spec.rb
 - spec/unit/plugins/airbrake_spec.rb
 - spec/unit/plugins/console_spec.rb
+- spec/unit/plugins/logstash_spec.rb
 homepage: https://github.com/pjanuario/logger-facade-ruby
 licenses:
 - MIT
@@ -214,5 +247,7 @@ test_files:
 - spec/unit/log_spec.rb
 - spec/unit/loggable_spec.rb
 - spec/unit/manager_spec.rb
+- spec/unit/middleware/rack_spec.rb
 - spec/unit/plugins/airbrake_spec.rb
 - spec/unit/plugins/console_spec.rb
+- spec/unit/plugins/logstash_spec.rb