syslogger 1.6.4 → 1.6.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c21391ce1c6dd9acb99edabd4dcd73a730ddb6c9
-  data.tar.gz: 94d556ab7bd1569c0eae7162a2541d9f27aeb6a1
+  metadata.gz: 10037fda0f96cf2e4073a7b721083696f1b30404
+  data.tar.gz: e483814598921fe12e703c5b519abe904121b290
 SHA512:
-  metadata.gz: 6abc0fcc0946fd0950a492b9a09b071d0636b1ebaaca8a5b9e73bf5cdd05589b25bd202b46f6842f222390d20a3e8a59d5b7ae170b6100ef279a43db798c18fc
-  data.tar.gz: 716670a2a752274f51874823618bec6874bbf832c14b82a1f51ba13afe7e431948d183cfd3897afce404d97e0d4f5f360dc1a9439f4d02c1d5dba0bffe615658
+  metadata.gz: 4eff79de93b2c28c2ec407d6d4675f815698894f0b4f2ceb79e9a7f0d96e54655310f96ccfa69244f3c742daa55e242491a09499a9f41827b40db969672d5be3
+  data.tar.gz: 66deff30ebd629b8d0251981b0c8f4530c72764bb0c56bdfdc97ba5ca403993626e098f106717020dbdc1abe0287dd3b53d3507bd33c75a36483a69035748872

data/.gitignore

@@ -0,0 +1,26 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+Gemfile.lock
+
+## PROJECT::SPECIFIC
+
+## RVM
+.rvmrc
+

data/.travis.yml

@@ -0,0 +1,9 @@
+dist: trusty
+language: ruby
+sudo: false
+cache: bundler
+rvm:
+  - 2.4.2
+  - 2.3.5
+  - 2.2.8
+  - jruby-9.1.9.0

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+# CHANGELOG
+
+## 1.6.5
+
+* Merge [Fixnum type is deprecated](https://github.com/crohr/syslogger/pull/42) (thanks thesmart)
+* Merge [Add #puts method to Syslogger](https://github.com/crohr/syslogger/pull/38) (thanks VuokkoVuorinnen)
+* Fix [Severity is passed as an array in the call to the formatter](https://github.com/crohr/syslogger/issues/35)
+* Save uniq tags in the thread
+* Improve tests

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -1,20 +1,21 @@
+The MIT License (MIT)
+
 Copyright (c) 2010 Cyril Rohr, INRIA Rennes-Bretagne Atlantique
 
-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:
+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 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.
+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,43 @@
+## Syslogger
+
+[![GitHub license](https://img.shields.io/github/license/crohr/syslogger.svg)](https://github.com/crohr/syslogger/blob/master/LICENSE)
+[![GitHub release](https://img.shields.io/github/release/crohr/syslogger.svg)](https://github.com/crohr/syslogger/releases/latest)
+[![Gem](https://img.shields.io/gem/v/syslogger.svg)](https://rubygems.org/gems/syslogger)
+[![Gem](https://img.shields.io/gem/dtv/syslogger.svg)](https://rubygems.org/gems/syslogger)
+[![Build Status](https://travis-ci.org/crohr/syslogger.svg?branch=master)](https://travis-ci.org/crohr/syslogger)
+
+A drop-in replacement for the standard Logger Ruby library, that logs to the syslog instead of a log file.
+Contrary to the SyslogLogger library, you can specify the facility and the syslog options.
+
+## Installation
+
+```sh
+$ gem install syslogger
+```
+
+## Usage
+
+```ruby
+require 'syslogger'
+
+# Will send all messages to the local0 facility, adding the process id in the message
+logger = Syslogger.new("app_name", Syslog::LOG_PID, Syslog::LOG_LOCAL0)
+
+# Optionally split messages to the specified number of bytes
+logger.max_octets = 480
+
+# Send messages that are at least of the Logger::INFO level
+logger.level = Logger::INFO # use Logger levels
+
+logger.debug "will not appear"
+logger.info "will appear"
+logger.warn "will appear"
+```
+
+## Contributions
+
+See <https://github.com/crohr/syslogger/contributors>.
+
+## Copyright
+
+Copyright (c) 2010 Cyril Rohr, INRIA Rennes-Bretagne Atlantique. See LICENSE for details.

data/Rakefile

@@ -1,17 +1,8 @@
-require 'bundler'
-Bundler.require
-
 require 'rspec/core/rake_task'
 require 'rdoc/task'
 
-$LOAD_PATH.unshift(File.expand_path('../lib', __FILE__))
-
-RSpec::Core::RakeTask.new(:spec) do |spec|
-end
-
-RSpec::Core::RakeTask.new(:rcov) do |spec|
-  spec.rcov = true
-end
+RSpec::Core::RakeTask.new(:spec)
+task default: :spec
 
 Rake::RDocTask.new do |rdoc|
   require 'syslogger'
@@ -20,5 +11,3 @@ Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_files.include('README*')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
-
-task :default => :spec

data/lib/syslogger.rb

@@ -4,21 +4,19 @@ require 'thread'
 
 class Syslogger
 
-  VERSION = "1.6.4"
-  
   MUTEX = Mutex.new
 
   attr_reader :level, :ident, :options, :facility, :max_octets
   attr_accessor :formatter
 
   MAPPING = {
-    Logger::DEBUG => Syslog::LOG_DEBUG,
-    Logger::INFO => Syslog::LOG_INFO,
-    Logger::WARN => Syslog::LOG_WARNING,
-    Logger::ERROR => Syslog::LOG_ERR,
-    Logger::FATAL => Syslog::LOG_CRIT,
+    Logger::DEBUG   => Syslog::LOG_DEBUG,
+    Logger::INFO    => Syslog::LOG_INFO,
+    Logger::WARN    => Syslog::LOG_WARNING,
+    Logger::ERROR   => Syslog::LOG_ERR,
+    Logger::FATAL   => Syslog::LOG_CRIT,
     Logger::UNKNOWN => Syslog::LOG_ALERT
-  }
+  }.freeze
 
   #
   # Initializes default options for the logger
@@ -45,11 +43,11 @@ class Syslogger
   #   logger.info "my_subapp" { "Some lazily computed message" }
   #
   def initialize(ident = $0, options = Syslog::LOG_PID | Syslog::LOG_CONS, facility = nil)
-    @ident = ident
-    @options = options || (Syslog::LOG_PID | Syslog::LOG_CONS)
-    @facility = facility
-    @level = Logger::INFO
-    @formatter = proc do |severity, datetime, progname, msg|
+    @ident     = ident
+    @options   = options || (Syslog::LOG_PID | Syslog::LOG_CONS)
+    @facility  = facility
+    @level     = Logger::INFO
+    @formatter = proc do |_, _, _, msg|
       msg
     end
   end
@@ -80,6 +78,10 @@ class Syslogger
     add(Logger::INFO, msg)
   end
 
+  def puts(msg)
+    add(Logger::INFO, msg)
+  end
+
   # Low level method to add a message.
   # +severity+::  the level of the message. One of Logger::DEBUG, Logger::INFO, Logger::WARN, Logger::ERROR, Logger::FATAL, Logger::UNKNOWN
   # +message+:: the message string.
@@ -93,27 +95,10 @@ class Syslogger
     progname ||= @ident
     mask = Syslog::LOG_UPTO(MAPPING[@level])
     communication = message || block && block.call
-    formatted_communication = clean(formatter.call([severity], Time.now, progname, communication))
-    
-    MUTEX.synchronize do
-      Syslog.open(progname, @options, @facility) do |s|
-        s.mask = mask
-        if self.max_octets
-          buffer = "#{tags_text}"
-          formatted_communication.bytes do |byte|
-            buffer.concat(byte)
-            # if the last byte we added is potentially part of an escape, we'll go ahead and add another byte
-            if buffer.bytesize >= self.max_octets && !['%'.ord,'\\'.ord].include?(byte)
-              s.log(MAPPING[severity],buffer)
-              buffer = ""
-            end
-          end
-          s.log(MAPPING[severity],buffer) unless buffer.empty?
-        else
-          s.log(MAPPING[severity],"#{tags_text}#{formatted_communication}")
-        end
-      end
-    end
+    formatted_communication = clean(formatter.call(severity, Time.now, progname, communication))
+
+    # Call Syslog
+    syslog_add(progname, severity, mask, formatted_communication)
   end
 
   # Set the max octets of the messages written to the log
@@ -124,13 +109,7 @@ class Syslogger
   # Sets the minimum level for messages to be written in the log.
   # +level+:: one of <tt>Logger::DEBUG</tt>, <tt>Logger::INFO</tt>, <tt>Logger::WARN</tt>, <tt>Logger::ERROR</tt>, <tt>Logger::FATAL</tt>, <tt>Logger::UNKNOWN</tt>
   def level=(level)
-    level = Logger.const_get(level.to_s.upcase) if level.is_a?(Symbol)
-
-    unless level.is_a?(Fixnum)
-      raise ArgumentError.new("Invalid logger level `#{level.inspect}`")
-    end
-
-    @level = level
+    @level = sanitize_level(level)
   end
 
   # Sets the ident string passed along to Syslog
@@ -147,8 +126,8 @@ class Syslogger
   end
 
   def push_tags(*tags)
-    tags.flatten.reject{ |i| i.respond_to?(:empty?) ? i.empty? : !i }.tap do |new_tags|
-      current_tags.concat new_tags
+    tags.flatten.reject { |i| i.respond_to?(:empty?) ? i.empty? : !i }.tap do |new_tags|
+      current_tags.concat(new_tags).uniq!
     end
   end
 
@@ -160,8 +139,26 @@ class Syslogger
     current_tags.clear
   end
 
+  def current_tags
+    Thread.current[:syslogger_tagged_logging_tags] ||= []
+  end
+
   protected
 
+  def sanitize_level(new_level)
+    begin
+      new_level = Logger.const_get(new_level.to_s.upcase)
+    rescue => _
+      raise ArgumentError.new("Invalid logger level `#{new_level.inspect}`")
+    end if new_level.is_a?(Symbol)
+
+    unless new_level.is_a?(Integer)
+      raise ArgumentError.new("Invalid logger level `#{new_level.inspect}`")
+    end
+
+    new_level
+  end
+
   # Borrowed from SyslogLogger.
   def clean(message)
     message = message.to_s.dup
@@ -177,11 +174,29 @@ class Syslogger
   def tags_text
     tags = current_tags
     if tags.any?
-      clean(tags.collect { |tag| "[#{tag}] " }.join) << " "
+      clean(tags.collect { |tag| "[#{tag}] " }.join) << ' '
     end
   end
 
-  def current_tags
-    Thread.current[:syslogger_tagged_logging_tags] ||= []
+  def syslog_add(progname, severity, mask, formatted_communication)
+    MUTEX.synchronize do
+      Syslog.open(progname, @options, @facility) do |s|
+        s.mask = mask
+        if self.max_octets
+          buffer = "#{tags_text}"
+          formatted_communication.bytes do |byte|
+            buffer.concat(byte)
+            # if the last byte we added is potentially part of an escape, we'll go ahead and add another byte
+            if buffer.bytesize >= self.max_octets && !['%'.ord,'\\'.ord].include?(byte)
+              s.log(MAPPING[severity], buffer)
+              buffer = ''
+            end
+          end
+          s.log(MAPPING[severity], buffer) unless buffer.empty?
+        else
+          s.log(MAPPING[severity], "#{tags_text}#{formatted_communication}")
+        end
+      end
+    end
   end
 end

data/lib/syslogger/version.rb

@@ -0,0 +1,3 @@
+class Syslogger
+  VERSION = '1.6.5'.freeze
+end

data/spec/spec_helper.rb

@@ -1,5 +1,21 @@
+require 'simplecov'
 require 'rspec'
 
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+# Start Simplecov
+SimpleCov.start
+
+# Configure RSpec
+RSpec.configure do |config|
+  config.color = true
+  config.fail_fast = false
+
+  config.order = :random
+  Kernel.srand config.seed
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end
+
+# Load lib
 require 'syslogger'

data/spec/syslogger_spec.rb

@@ -1,274 +1,196 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe "Syslogger" do
-  it "should log to the default syslog facility, with the default options" do
-    logger = Syslogger.new
-    Syslog.should_receive(:open).with($0, Syslog::LOG_PID | Syslog::LOG_CONS, nil).and_yield(syslog=double("syslog", :mask= => true))
-    syslog.should_receive(:log).with(Syslog::LOG_WARNING, "Some message")
-    logger.warn "Some message"
-  end
+require 'spec_helper'
 
-  it "should log to the user facility, with specific options" do
-    logger = Syslogger.new("my_app", Syslog::LOG_PID, Syslog::LOG_USER)
-    Syslog.should_receive(:open).with("my_app", Syslog::LOG_PID, Syslog::LOG_USER).and_yield(syslog=double("syslog", :mask= => true))
-    syslog.should_receive(:log).with(Syslog::LOG_WARNING, "Some message")
-    logger.warn "Some message"
-  end
+describe Syslogger do
 
-  %w{debug info warn error fatal unknown}.each do |logger_method|
-    it "should respond to the #{logger_method.inspect} method" do
-      Syslogger.new.should respond_to logger_method.to_sym
-    end
+  let(:fake_syslog) { double('syslog', :mask= => true) }
 
-    it "should log #{logger_method} without raising an exception if called with a block" do
+  describe '.new' do
+    it 'should log to the default syslog facility, with the default options' do
+      expect(Syslog).to receive(:open).with($0, Syslog::LOG_PID | Syslog::LOG_CONS, nil).and_yield(fake_syslog)
+      expect(fake_syslog).to receive(:log).with(Syslog::LOG_WARNING, 'Some message')
       logger = Syslogger.new
-      logger.level = Logger.const_get(logger_method.upcase)
-      Syslog.stub(:open).and_yield(syslog=double("syslog", :mask= => true))
-      severity = Syslogger::MAPPING[Logger.const_get(logger_method.upcase)]
-      syslog.should_receive(:log).with(severity, "Some message that doesn't need to be in a block")
-      lambda {
-        logger.send(logger_method.to_sym) { "Some message that doesn't need to be in a block" }
-      }.should_not raise_error
+      logger.warn 'Some message'
     end
 
-    it "should log #{logger_method} using message as progname with the block's result" do
-      logger = Syslogger.new
-      logger.level = Logger.const_get(logger_method.upcase)
-      Syslog.should_receive(:open).with("Woah", anything, nil)
-        .and_yield(syslog=double("syslog", :mask= => true))
-      severity = Syslogger::MAPPING[Logger.const_get(logger_method.upcase)]
-      syslog.should_receive(:log).with(severity, "Some message that really needs a block")
-      lambda {
-        logger.send(logger_method.to_sym, "Woah") { "Some message that really needs a block" }
-      }.should_not raise_error
+    it 'should log to the user facility, with specific options' do
+      expect(Syslog).to receive(:open).with('my_app', Syslog::LOG_PID, Syslog::LOG_USER).and_yield(fake_syslog)
+      expect(fake_syslog).to receive(:log).with(Syslog::LOG_WARNING, 'Some message')
+      logger = Syslogger.new('my_app', Syslog::LOG_PID, Syslog::LOG_USER)
+      logger.warn 'Some message'
     end
+  end
 
-    it "should log #{logger_method} without raising an exception if called with a nil message" do
-      logger = Syslogger.new
-      lambda {
-        logger.send(logger_method.to_sym, nil)
-      }.should_not raise_error
+  describe '#add' do
+    let(:logger) { Syslogger.new('my_app', Syslog::LOG_PID, Syslog::LOG_USER) }
+
+    it 'should respond to add' do
+      expect(logger).to respond_to(:add)
     end
 
-    it "should log #{logger_method} without raising an exception if called with a no message" do
-      logger = Syslogger.new
-      lambda {
-        logger.send(logger_method.to_sym)
-      }.should_not raise_error
+    it 'should correctly log' do
+      expect(Syslog).to receive(:open).with('my_app', Syslog::LOG_PID, Syslog::LOG_USER).and_yield(fake_syslog)
+      expect(fake_syslog).to receive(:log).with(Syslog::LOG_INFO, 'message')
+      logger.add(Logger::INFO, 'message')
     end
 
-    it "should log #{logger_method} without raising an exception if message splits on an escape" do
-      logger = Syslogger.new
-      logger.max_octets=100
-      msg="A"*99
-      msg+="%BBB"
-      lambda {
-        logger.send(logger_method.to_sym,msg)
-      }.should_not raise_error
+    it 'should take the message from the block if :message is nil' do
+      expect(Syslog).to receive(:open).with('my_app', Syslog::LOG_PID, Syslog::LOG_USER).and_yield(fake_syslog)
+      expect(fake_syslog).to receive(:log).with(Syslog::LOG_INFO, 'message')
+      logger.add(Logger::INFO) { 'message' }
     end
-  end
 
-  %w{debug info warn error}.each do |logger_method|
-    it "should not log #{logger_method} when level is higher" do
-      logger = Syslogger.new
-      logger.level = Logger::FATAL
-      Syslog.should_not_receive(:open).with($0, Syslog::LOG_PID | Syslog::LOG_CONS, nil).and_yield(syslog=double("syslog", :mask= => true))
-      syslog.should_not_receive(:log).with(Syslog::LOG_NOTICE, "Some message")
-      logger.send(logger_method.to_sym, "Some message")
+    it 'should use the given progname' do
+      expect(Syslog).to receive(:open).with('progname', Syslog::LOG_PID, Syslog::LOG_USER).and_yield(fake_syslog)
+      expect(fake_syslog).to receive(:log).with(Syslog::LOG_INFO, 'message')
+      logger.add(Logger::INFO, 'message', 'progname')
     end
 
-    it "should not evaluate a block or log #{logger_method} when level is higher" do
-      logger = Syslogger.new
-      logger.level = Logger::FATAL
-      Syslog.should_not_receive(:open).with($0, Syslog::LOG_PID | Syslog::LOG_CONS, nil).and_yield(syslog=double("syslog", :mask= => true))
-      syslog.should_not_receive(:log).with(Syslog::LOG_NOTICE, "Some message")
-      logger.send(logger_method.to_sym) { violated "This block should not have been called" }
+    it 'should use the default progname when message is passed in progname' do
+      expect(Syslog).to receive(:open).with('my_app', Syslog::LOG_PID, Syslog::LOG_USER).and_yield(fake_syslog)
+      expect(fake_syslog).to receive(:log).with(Syslog::LOG_INFO, 'message')
+      logger.add(Logger::INFO, nil, 'message')
     end
-  end
 
-  it "should respond to <<" do
-    logger = Syslogger.new("my_app", Syslog::LOG_PID, Syslog::LOG_USER)
-    logger.should respond_to(:<<)
-    Syslog.should_receive(:open).with("my_app", Syslog::LOG_PID, Syslog::LOG_USER).and_yield(syslog=double("syslog", :mask= => true))
-    syslog.should_receive(:log).with(Syslog::LOG_INFO, "yop")
-    logger << "yop"
-  end
+    it 'should use the given progname if message is passed in block' do
+      expect(Syslog).to receive(:open).with('progname', Syslog::LOG_PID, Syslog::LOG_USER).and_yield(fake_syslog)
+      expect(fake_syslog).to receive(:log).with(Syslog::LOG_INFO, 'message')
+      logger.add(Logger::INFO, nil, 'progname') { 'message' }
+    end
 
-  it "should respond to write" do
-    logger = Syslogger.new("my_app", Syslog::LOG_PID, Syslog::LOG_USER)
-    logger.should respond_to(:write)
-    Syslog.should_receive(:open).with("my_app", Syslog::LOG_PID, Syslog::LOG_USER).and_yield(syslog=double("syslog", :mask= => true))
-    syslog.should_receive(:log).with(Syslog::LOG_INFO, "yop")
-    logger.write "yop"
-  end
+    it "should substitute '%' for '%%' before adding the :message" do
+      allow(Syslog).to receive(:open).and_yield(fake_syslog)
+      expect(fake_syslog).to receive(:log).with(Syslog::LOG_INFO, "%%me%%ssage%%")
+      logger.add(Logger::INFO, "%me%ssage%")
+    end
 
-  it "should allow multiple instances to log at the same time" do
-    logger1 = Syslogger.new("my_app1", Syslog::LOG_PID, Syslog::LOG_USER)
-    logger2 = Syslogger.new("my_app2", Syslog::LOG_PID, Syslog::LOG_USER)
+    it 'should clean formatted message' do
+      allow(Syslog).to receive(:open).and_yield(fake_syslog)
+      expect(fake_syslog).to receive(:log).with(Syslog::LOG_INFO, "m%%e%%s%%s%%a%%g%%e")
 
-    thread1 = Thread.new do
-      5000.times do |i|
-        logger1.write "logger1"
-      end
-    end
+      original_formatter = logger.formatter
 
-    thread2 = Thread.new do
-      5000.times do |i|
-        logger2.write "logger1"
+      begin
+        logger.formatter = proc do |severity, datetime, progname, msg|
+          msg.split(//).join('%')
+        end
+        logger.add(Logger::INFO, 'message')
+      ensure
+        logger.formatter = original_formatter
       end
     end
 
-    thread1.join
-    thread2.join
-  end
-  
-  it "should not fail under chaos" do
-    threads = []
-    (1..10).each do
-      threads << Thread.new do
-        (1..100).each do |index|
-          logger = Syslogger.new(Thread.current.inspect, Syslog::LOG_PID, Syslog::LOG_USER)
-          logger.write index
+    it 'should clean tagged message' do
+      allow(Syslog).to receive(:open).and_yield(fake_syslog)
+      expect(fake_syslog).to receive(:log).with(Syslog::LOG_INFO, "[t%%a%%g%%g%%e%%d] [it] message")
+
+      logger.tagged("t%a%g%g%e%d") do
+        logger.tagged('it') do
+          logger.add(Logger::INFO, 'message')
         end
       end
     end
-    
-    threads.each{|thread| thread.join }
-  end
 
-  describe "add" do
-    before do
-      @logger = Syslogger.new("my_app", Syslog::LOG_PID, Syslog::LOG_USER)
-    end
-    it "should respond to add" do
-      @logger.should respond_to(:add)
-    end
-    it "should correctly log" do
-      Syslog.should_receive(:open).with("my_app", Syslog::LOG_PID, Syslog::LOG_USER).and_yield(syslog=double("syslog", :mask= => true))
-      syslog.should_receive(:log).with(Syslog::LOG_INFO, "message")
-      @logger.add(Logger::INFO, "message")
-    end
-    it "should take the message from the block if :message is nil" do
-      Syslog.should_receive(:open).with("my_app", Syslog::LOG_PID, Syslog::LOG_USER).and_yield(syslog=double("syslog", :mask= => true))
-      syslog.should_receive(:log).with(Syslog::LOG_INFO, "my message")
-      @logger.add(Logger::INFO) { "my message" }
+    it 'should strip the :message' do
+      allow(Syslog).to receive(:open).and_yield(fake_syslog)
+      expect(fake_syslog).to receive(:log).with(Syslog::LOG_INFO, 'message')
+      logger.add(Logger::INFO, "\n\nmessage  ")
     end
-    it "should use the given progname" do
-      Syslog.should_receive(:open).with("progname", Syslog::LOG_PID, Syslog::LOG_USER).and_yield(syslog=double("syslog", :mask= => true))
-      syslog.should_receive(:log).with(Syslog::LOG_INFO, "message")
-      @logger.add(Logger::INFO, "message", "progname") { "my message" }
-    end
-
-    it "should use the default progname when message is passed in progname" do
-      Syslog.should_receive(:open).
-        with("my_app", Syslog::LOG_PID, Syslog::LOG_USER).
-        and_yield(syslog = double("syslog", :mask= => true))
 
-      syslog.should_receive(:log).with(Syslog::LOG_INFO, "message")
-      @logger.add(Logger::INFO, nil, "message")
+    it 'should not raise exception if asked to log with a nil message and body' do
+      expect(Syslog).to receive(:open).with('my_app', Syslog::LOG_PID, Syslog::LOG_USER).and_yield(fake_syslog)
+      expect(fake_syslog).to receive(:log).with(Syslog::LOG_INFO, '')
+      expect {
+        logger.add(Logger::INFO, nil)
+      }.to_not raise_error
     end
 
-    it "should use the given progname if message is passed in block" do
-      Syslog.should_receive(:open).
-        with("progname", Syslog::LOG_PID, Syslog::LOG_USER).
-        and_yield(syslog = double("syslog", :mask= => true))
-
-      syslog.should_receive(:log).with(Syslog::LOG_INFO, "message")
-      @logger.add(Logger::INFO, nil, "progname") { "message" }
+    it 'should send an empty string if the message and block are nil' do
+      expect(Syslog).to receive(:open).with('my_app', Syslog::LOG_PID, Syslog::LOG_USER).and_yield(fake_syslog)
+      expect(fake_syslog).to receive(:log).with(Syslog::LOG_INFO, '')
+      logger.add(Logger::INFO, nil)
     end
 
-    it "should substitute '%' for '%%' before adding the :message" do
-      Syslog.stub(:open).and_yield(syslog=double("syslog", :mask= => true))
-      syslog.should_receive(:log).with(Syslog::LOG_INFO, "%%me%%ssage%%")
-      @logger.add(Logger::INFO, "%me%ssage%")
-    end
-    
-    it "should clean formatted message" do
-      Syslog.stub(:open).and_yield(syslog=double("syslog", :mask= => true))
-      syslog.should_receive(:log).with(Syslog::LOG_INFO, "m%%e%%s%%s%%a%%g%%e")
-      
-      original_formatter = @logger.formatter
-      begin
-        @logger.formatter = proc do |severity, datetime, progname, msg|
-          msg.split(//).join('%')
-        end
-        
-        @logger.add(Logger::INFO, "message")
-      ensure
-        @logger.formatter = original_formatter
-      end
+    it 'should split string over the max octet size' do
+      logger.max_octets = 480
+      expect(Syslog).to receive(:open).with('my_app', Syslog::LOG_PID, Syslog::LOG_USER).and_yield(fake_syslog)
+      expect(fake_syslog).to receive(:log).with(Syslog::LOG_INFO, 'a' * 480).twice
+      logger.add(Logger::INFO, 'a' * 960)
     end
-    
-    it "should clean tagged message" do
-      Syslog.stub(:open).and_yield(syslog=double("syslog", :mask= => true))
-      syslog.should_receive(:log).with(Syslog::LOG_INFO, "[t%%a%%g%%g%%e%%d] [it] message")
-      
-      @logger.tagged("t%a%g%g%e%d") do
-        @logger.tagged("it") do
-          @logger.add(Logger::INFO, "message")
-        end
+
+    it 'should apply the log formatter to the message' do
+      allow(Syslog).to receive(:open).and_yield(fake_syslog)
+      expect(fake_syslog).to receive(:log).with(Syslog::LOG_INFO, 'test message!')
+      logger.formatter = proc do |severity, datetime, progname, msg|
+        "test #{msg}!"
       end
+      logger.add(Logger::INFO, 'message')
     end
+  end
 
-    it "should strip the :message" do
-      Syslog.stub(:open).and_yield(syslog=double("syslog", :mask= => true))
-      syslog.should_receive(:log).with(Syslog::LOG_INFO, "message")
-      @logger.add(Logger::INFO, "\n\nmessage  ")
-    end
+  describe '#<<' do
+    let(:logger) { Syslogger.new('my_app', Syslog::LOG_PID, Syslog::LOG_USER) }
 
-    it "should not raise exception if asked to log with a nil message and body" do
-      Syslog.should_receive(:open).
-        with("my_app", Syslog::LOG_PID, Syslog::LOG_USER).
-        and_yield(syslog=double("syslog", :mask= => true))
-      syslog.should_receive(:log).with(Syslog::LOG_INFO, "")
-      lambda {
-        @logger.add(Logger::INFO, nil)
-      }.should_not raise_error
+    it 'should respond to <<' do
+      expect(logger).to respond_to(:<<)
     end
 
-    it "should send an empty string if the message and block are nil" do
-      Syslog.should_receive(:open).
-        with("my_app", Syslog::LOG_PID, Syslog::LOG_USER).
-        and_yield(syslog=double("syslog", :mask= => true))
-      syslog.should_receive(:log).with(Syslog::LOG_INFO, "")
-      @logger.add(Logger::INFO, nil)
+    it 'should correctly log' do
+      expect(Syslog).to receive(:open).with('my_app', Syslog::LOG_PID, Syslog::LOG_USER).and_yield(fake_syslog)
+      expect(fake_syslog).to receive(:log).with(Syslog::LOG_INFO, 'message')
+      logger << 'message'
     end
+  end
 
-    it "should split string over the max octet size" do
-      @logger.max_octets = 480
-      Syslog.should_receive(:open).
-        with("my_app", Syslog::LOG_PID, Syslog::LOG_USER).
-        and_yield(syslog=double("syslog", :mask= => true))
-      syslog.should_receive(:log).with(Syslog::LOG_INFO, "a"*480).twice
-      @logger.add(Logger::INFO, "a"*960)
+  describe '#puts' do
+    let(:logger) { Syslogger.new('my_app', Syslog::LOG_PID, Syslog::LOG_USER) }
+
+    it 'should respond to puts' do
+      expect(logger).to respond_to(:puts)
     end
 
-    it "should apply the log formatter to the message" do
-      Syslog.stub(:open).and_yield(syslog=double("syslog", :mask= => true))
-      syslog.should_receive(:log).with(Syslog::LOG_INFO, "test message!")
-      @logger.formatter = proc do |severity, datetime, progname, msg|
-        "test #{msg}!"
-      end
-      @logger.add(Logger::INFO, "message")
+    it 'should correctly log' do
+      expect(Syslog).to receive(:open).with('my_app', Syslog::LOG_PID, Syslog::LOG_USER).and_yield(fake_syslog)
+      expect(fake_syslog).to receive(:log).with(Syslog::LOG_INFO, 'message')
+      logger.puts 'message'
     end
-  end # describe "add"
+  end
 
-  describe "max_octets=" do
-    before(:each) do
-      @logger = Syslogger.new("my_app", Syslog::LOG_PID, Syslog::LOG_USER)
+  describe '#write' do
+    let(:logger) { Syslogger.new('my_app', Syslog::LOG_PID, Syslog::LOG_USER) }
+
+    it 'should respond to write' do
+      expect(logger).to respond_to(:write)
     end
 
-    it "should set the max_octets for the logger" do
-      lambda { @logger.max_octets = 1 }.should change(@logger, :max_octets)
-      @logger.max_octets.should == 1
+    it 'should correctly log' do
+      expect(Syslog).to receive(:open).with('my_app', Syslog::LOG_PID, Syslog::LOG_USER).and_yield(fake_syslog)
+      expect(fake_syslog).to receive(:log).with(Syslog::LOG_INFO, 'message')
+      logger.write 'message'
     end
+  end
 
+  describe '#max_octets=' do
+    let(:logger) { Syslogger.new('my_app', Syslog::LOG_PID, Syslog::LOG_USER) }
+
+    it 'should set the max_octets for the logger' do
+      expect { logger.max_octets = 1 }.to change(logger, :max_octets)
+      expect(logger.max_octets).to eq 1
+    end
   end
 
-  describe "level=" do
-    before(:each) do
-      @logger = Syslogger.new("my_app", Syslog::LOG_PID, Syslog::LOG_USER)
+  describe '#ident=' do
+    let(:logger) { Syslogger.new('my_app', Syslog::LOG_PID | Syslog::LOG_CONS, nil) }
+
+    it 'should permanently change the ident string' do
+      logger.ident = 'new_ident'
+      expect(Syslog).to receive(:open).with('new_ident', Syslog::LOG_PID | Syslog::LOG_CONS, nil).and_yield(fake_syslog)
+      expect(fake_syslog).to receive(:log)
+      logger.warn('should get the new ident string')
     end
+  end
+
+  describe '#level=' do
+    let(:logger) { Syslogger.new('my_app', Syslog::LOG_PID, Syslog::LOG_USER) }
 
     { :debug => Logger::DEBUG,
       :info  => Logger::INFO,
@@ -277,105 +199,257 @@ describe "Syslogger" do
       :fatal => Logger::FATAL
     }.each_pair do |level_symbol, level_value|
       it "should allow using :#{level_symbol}" do
-        @logger.level = level_symbol
-        @logger.level.should equal level_value
+        logger.level = level_symbol
+        expect(logger.level).to eq level_value
       end
 
-      it "should allow using Fixnum #{level_value}" do
-        @logger.level = level_value
-        @logger.level.should equal level_value
+      it "should allow using Integer #{level_value}" do
+        logger.level = level_value
+        expect(logger.level).to eq level_value
       end
     end
 
-    it "should not allow using random symbols" do
-      lambda {
-        @logger.level = :foo
-      }.should raise_error
+    it 'should not allow using random symbols' do
+      expect {
+        logger.level = :foo
+      }.to raise_error(ArgumentError)
     end
 
-    it "should not allow using symbols mapping back to non-level constants" do
-      lambda {
-        @logger.level = :version
-      }.should raise_error
+    it 'should not allow using symbols mapping back to non-level constants' do
+      expect {
+        logger.level = :version
+      }.to raise_error(ArgumentError)
     end
 
-    it "should not allow using strings" do
-      lambda {
-        @logger.level = "warn"
-      }.should raise_error
+    it 'should not allow using strings' do
+      expect {
+        logger.level = 'warn'
+      }.to raise_error(ArgumentError)
     end
-  end # describe "level="
+  end
 
-  describe "ident=" do
-    before(:each) do
-      @logger = Syslogger.new("my_app", Syslog::LOG_PID | Syslog::LOG_CONS, nil)
+  describe '#:level? methods' do
+    let(:logger) { Syslogger.new('my_app', Syslog::LOG_PID, Syslog::LOG_USER) }
+
+    %w{debug info warn error fatal}.each do |logger_method|
+      it "should respond to the #{logger_method}? method" do
+        expect(logger).to respond_to "#{logger_method}?".to_sym
+      end
     end
 
-    it "should permanently change the ident string" do
-      @logger.ident = "new_ident"
-      Syslog.should_receive(:open).with("new_ident", Syslog::LOG_PID | Syslog::LOG_CONS, nil).and_yield(syslog=double("syslog", :mask= => true))
-      syslog.should_receive(:log)
-      @logger.warn("should get the new ident string")
+    it 'should not have unknown? method' do
+      expect(logger).to_not respond_to :unknown?
     end
-  end
 
-  describe ":level? methods" do
-    before(:each) do
-      @logger = Syslogger.new("my_app", Syslog::LOG_PID, Syslog::LOG_USER)
+    context 'when loglevel is Logger::DEBUG' do
+      it 'should return true for all methods' do
+        logger.level = Logger::DEBUG
+        %w{debug info warn error fatal}.each do |logger_method|
+          expect(logger.send("#{logger_method}?")).to be true
+        end
+      end
     end
 
-    %w{debug info warn error fatal}.each do |logger_method|
-      it "should respond to the #{logger_method}? method" do
-        @logger.should respond_to "#{logger_method}?".to_sym
+    context 'when loglevel is Logger::INFO' do
+      it 'should return true for all except debug?' do
+        logger.level = Logger::INFO
+        %w{info warn error fatal}.each do |logger_method|
+          expect(logger.send("#{logger_method}?")).to be true
+        end
+        expect(logger.debug?).to be false
       end
     end
 
-    it "should not have unknown? method" do
-      @logger.should_not respond_to :unknown?
+    context 'when loglevel is Logger::WARN' do
+      it 'should return true for warn?, error? and fatal? when WARN' do
+        logger.level = Logger::WARN
+        %w{warn error fatal}.each do |logger_method|
+          expect(logger.send("#{logger_method}?")).to be true
+        end
+        %w{debug info}.each do |logger_method|
+          expect(logger.send("#{logger_method}?")).to be false
+        end
+      end
     end
 
-    it "should return true for all methods" do
-      @logger.level = Logger::DEBUG
-      %w{debug info warn error fatal}.each do |logger_method|
-        @logger.send("#{logger_method}?").should be_true
+    context 'when loglevel is Logger::ERROR' do
+      it 'should return true for error? and fatal? when ERROR' do
+        logger.level = Logger::ERROR
+        %w{error fatal}.each do |logger_method|
+          expect(logger.send("#{logger_method}?")).to be true
+        end
+        %w{warn debug info}.each do |logger_method|
+          expect(logger.send("#{logger_method}?")).to be false
+        end
       end
     end
 
-    it "should return true for all except debug?" do
-      @logger.level = Logger::INFO
-      %w{info warn error fatal}.each do |logger_method|
-        @logger.send("#{logger_method}?").should be_true
+    context 'when loglevel is Logger::FATAL' do
+      it 'should return true only for fatal? when FATAL' do
+        logger.level = Logger::FATAL
+        expect(logger.fatal?).to be true
+        %w{error warn debug info}.each do |logger_method|
+          expect(logger.send("#{logger_method}?")).to be false
+        end
       end
-      @logger.debug?.should be_false
     end
+  end
+
+  describe '#push_tags' do
+    let(:logger) { Syslogger.new('my_app', Syslog::LOG_PID, Syslog::LOG_USER) }
+    after(:each) { logger.clear_tags! }
+
+    it 'saves tags' do
+      logger.push_tags('tag1')
+      logger.push_tags('tag2')
+      expect(logger.current_tags).to eq ['tag1', 'tag2']
+    end
+
+    it 'saves uniq tags' do
+      logger.push_tags('tag1')
+      logger.push_tags('tag2')
+      logger.push_tags('foo')
+      logger.push_tags('foo')
+      expect(logger.current_tags).to eq ['tag1', 'tag2', 'foo']
+    end
+  end
+
+  describe '#clear_tags!' do
+    let(:logger) { Syslogger.new('my_app', Syslog::LOG_PID, Syslog::LOG_USER) }
+    after(:each) { logger.clear_tags! }
 
-    it "should return true for warn?, error? and fatal? when WARN" do
-      @logger.level = Logger::WARN
-      %w{warn error fatal}.each do |logger_method|
-        @logger.send("#{logger_method}?").should be_true
+    it 'clears tags' do
+      expect(logger.current_tags).to eq []
+      logger.push_tags('tag1')
+      logger.push_tags('tag2')
+      expect(logger.current_tags).to eq ['tag1', 'tag2']
+      logger.clear_tags!
+      expect(logger.current_tags).to eq []
+    end
+  end
+
+  describe 'logger methods (debug info warn error fatal unknown)' do
+    %w{debug info warn error fatal unknown}.each do |logger_method|
+
+      it "should respond to the #{logger_method.inspect} method" do
+        expect(Syslogger.new).to respond_to logger_method.to_sym
       end
-      %w{debug info}.each do |logger_method|
-        @logger.send("#{logger_method}?").should be_false
+
+      it "should log #{logger_method} without raising an exception if called with a block" do
+        severity = Syslogger::MAPPING[Logger.const_get(logger_method.upcase)]
+
+        logger = Syslogger.new
+        logger.level = Logger.const_get(logger_method.upcase)
+
+        expect(Syslog).to receive(:open).and_yield(fake_syslog)
+        expect(fake_syslog).to receive(:log).with(severity, 'Some message that dont need to be in a block')
+        expect {
+          logger.send(logger_method.to_sym) { 'Some message that dont need to be in a block' }
+        }.to_not raise_error
       end
-    end
 
-    it "should return true for error? and fatal? when ERROR" do
-      @logger.level = Logger::ERROR
-      %w{error fatal}.each do |logger_method|
-        @logger.send("#{logger_method}?").should be_true
+      it "should log #{logger_method} using message as progname with the block's result" do
+        severity = Syslogger::MAPPING[Logger.const_get(logger_method.upcase)]
+
+        logger = Syslogger.new
+        logger.level = Logger.const_get(logger_method.upcase)
+
+        expect(Syslog).to receive(:open).with('Woah', anything, nil).and_yield(fake_syslog)
+        expect(fake_syslog).to receive(:log).with(severity, 'Some message that really needs a block')
+        expect {
+          logger.send(logger_method.to_sym, 'Woah') { 'Some message that really needs a block' }
+        }.to_not raise_error
+      end
+
+      it "should log #{logger_method} without raising an exception if called with a nil message" do
+        logger = Syslogger.new
+        expect {
+          logger.send(logger_method.to_sym, nil)
+        }.to_not raise_error
+      end
+
+      it "should log #{logger_method} without raising an exception if called with a no message" do
+        logger = Syslogger.new
+        expect {
+          logger.send(logger_method.to_sym)
+        }.to_not raise_error
       end
-      %w{warn debug info}.each do |logger_method|
-        @logger.send("#{logger_method}?").should be_false
+
+      it "should log #{logger_method} without raising an exception if message splits on an escape" do
+        logger = Syslogger.new
+        logger.max_octets = 100
+        msg  = 'A' * 99
+        msg += "%BBB"
+        expect {
+          logger.send(logger_method.to_sym, msg)
+        }.to_not raise_error
       end
     end
+  end
+
+  describe 'it should be thread safe' do
+    it 'should not fail under chaos' do
+      threads = []
+      (1..10).each do
+        threads << Thread.new do
+          (1..100).each do |index|
+            logger = Syslogger.new(Thread.current.inspect, Syslog::LOG_PID, Syslog::LOG_USER)
+            logger.write index
+          end
+        end
+      end
+
+      threads.map(&:join)
+    end
+
+    it 'should allow multiple instances to log at the same time' do
+      logger1 = Syslogger.new('my_app1', Syslog::LOG_PID, Syslog::LOG_USER)
+      logger2 = Syslogger.new('my_app2', Syslog::LOG_PID, Syslog::LOG_USER)
+
+      syslog1 = double('syslog1', :mask= => true)
+      syslog2 = double('syslog2', :mask= => true)
+
+      expect(Syslog).to receive(:open).exactly(5000).times.with('my_app1', Syslog::LOG_PID, Syslog::LOG_USER).and_yield(syslog1)
+      expect(Syslog).to receive(:open).exactly(5000).times.with('my_app2', Syslog::LOG_PID, Syslog::LOG_USER).and_yield(syslog2)
 
-    it "should return true only for fatal? when FATAL" do
-      @logger.level = Logger::FATAL
-      @logger.fatal?.should be_true
-      %w{error warn debug info}.each do |logger_method|
-        @logger.send("#{logger_method}?").should be_false
+      expect(syslog1).to receive(:log).exactly(5000).times.with(Syslog::LOG_INFO, 'logger1')
+      expect(syslog2).to receive(:log).exactly(5000).times.with(Syslog::LOG_INFO, 'logger2')
+
+      threads = []
+
+      threads << Thread.new do
+        5000.times do |i|
+          logger1.info 'logger1'
+        end
+      end
+
+      threads << Thread.new do
+        5000.times do |i|
+          logger2.info 'logger2'
+        end
       end
+
+      threads.map(&:join)
     end
-  end # describe ":level? methods"
+  end
+
+  describe 'it should respect loglevel precedence when logging' do
+    %w{debug info warn error}.each do |logger_method|
+      it "should not log #{logger_method} when level is higher" do
+        logger = Syslogger.new
+        logger.level = Logger::FATAL
+        expect(Syslog).to_not receive(:open).with($0, Syslog::LOG_PID | Syslog::LOG_CONS, nil).and_yield(fake_syslog)
+        expect(fake_syslog).to_not receive(:log).with(Syslog::LOG_NOTICE, 'Some message')
+        logger.send(logger_method.to_sym, 'Some message')
+      end
 
-end # describe "Syslogger"
+      it "should not evaluate a block or log #{logger_method} when level is higher" do
+        logger = Syslogger.new
+        logger.level = Logger::FATAL
+        expect(Syslog).to_not receive(:open).with($0, Syslog::LOG_PID | Syslog::LOG_CONS, nil).and_yield(fake_syslog)
+        expect(fake_syslog).to_not receive(:log).with(Syslog::LOG_NOTICE, 'Some message')
+        logger.send(logger_method.to_sym) { violated 'This block should not have been called' }
+      end
+    end
+  end
+end