steno 1.2.4 → 1.3.5

data/spec/unit/sink/io_spec.rb

@@ -1,4 +1,4 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Steno::Sink::IO do
   let(:level) do
@@ -6,104 +6,104 @@ describe Steno::Sink::IO do
   end
 
   let(:record) do
-    Steno::Record.new("source", level.name, "message")
+    Steno::Record.new('source', level.name, 'message')
   end
 
-  describe ".for_file" do
-    it "should return a new sink configured to append to the file at path with autosync set to true by default" do
-      mock_handle = double("file handle")
+  describe '.for_file' do
+    it 'returns a new sink configured to append to the file at path with autosync set to true by default' do
+      mock_handle = double('file handle')
 
-      File.should_receive(:open).with("path", "a+").and_return(mock_handle)
-      mock_handle.should_receive(:sync=).with(true)
+      expect(File).to receive(:open).with('path', 'a+').and_return(mock_handle)
+      expect(mock_handle).to receive(:sync=).with(true)
 
-      mock_sink = double("sink")
-      Steno::Sink::IO.should_receive(:new).with(mock_handle,
-                                                :max_retries => 10).
-        and_return(mock_sink)
+      mock_sink = double('sink')
+      expect(Steno::Sink::IO).to receive(:new).with(mock_handle,
+                                                    max_retries: 10)
+                                              .and_return(mock_sink)
 
-      returned = Steno::Sink::IO.for_file("path",
-                                          :max_retries => 10)
-      returned.should == mock_sink
+      returned = Steno::Sink::IO.for_file('path',
+                                          max_retries: 10)
+      expect(returned).to eq(mock_sink)
     end
 
-    it "should return a new sink configured to append to the file at path with specified options" do
-      mock_handle = double("file handle")
+    it 'returns a new sink configured to append to the file at path with specified options' do
+      mock_handle = double('file handle')
 
-      File.should_receive(:open).with("path", "a+").and_return(mock_handle)
-      mock_handle.should_receive(:sync=).with(false)
+      expect(File).to receive(:open).with('path', 'a+').and_return(mock_handle)
+      expect(mock_handle).to receive(:sync=).with(false)
 
-      mock_sink = double("sink")
-      Steno::Sink::IO.should_receive(:new).with(mock_handle,
-                                                :max_retries => 10).
-        and_return(mock_sink)
+      mock_sink = double('sink')
+      expect(Steno::Sink::IO).to receive(:new).with(mock_handle,
+                                                    max_retries: 10)
+                                              .and_return(mock_sink)
 
-      returned = Steno::Sink::IO.for_file("path",
-                                          :autoflush => false,
-                                          :max_retries => 10)
-      returned.should == mock_sink
+      returned = Steno::Sink::IO.for_file('path',
+                                          autoflush: false,
+                                          max_retries: 10)
+      expect(returned).to eq(mock_sink)
     end
   end
 
-  describe "#add_record" do
-    it "should encode the record and write it to the underlying io object" do
-      codec = double("codec")
-      codec.should_receive(:encode_record).with(record).and_return(record.message)
+  describe '#add_record' do
+    it 'encodes the record and write it to the underlying io object' do
+      codec = double('codec')
+      expect(codec).to receive(:encode_record).with(record).and_return(record.message)
 
-      io = double("io")
-      io.should_receive(:write).with(record.message)
+      io = double('io')
+      expect(io).to receive(:write).with(record.message)
 
-      Steno::Sink::IO.new(io, :codec => codec).add_record(record)
+      Steno::Sink::IO.new(io, codec: codec).add_record(record)
     end
 
-    it "should by default not retry on IOError" do
-      codec = double("codec")
-      codec.should_receive(:encode_record).with(record).and_return(record.message)
+    it 'bies default not retry on IOError' do
+      codec = double('codec')
+      expect(codec).to receive(:encode_record).with(record).and_return(record.message)
 
-      io = double("io")
+      io = double('io')
 
-      io.should_receive(:write).with(record.message).ordered.and_raise(IOError)
+      expect(io).to receive(:write).with(record.message).ordered.and_raise(IOError)
 
       expect do
-        Steno::Sink::IO.new(io, :codec => codec).add_record(record)
+        Steno::Sink::IO.new(io, codec: codec).add_record(record)
       end.to raise_error(IOError)
     end
 
-    it "should retry not more than specified number of times on IOError" do
-      codec = double("codec")
-      codec.should_receive(:encode_record).with(record).and_return(record.message)
+    it 'retries not more than specified number of times on IOError' do
+      codec = double('codec')
+      expect(codec).to receive(:encode_record).with(record).and_return(record.message)
 
-      io = double("io")
+      io = double('io')
 
-      io.should_receive(:write).exactly(3).times.with(record.message).
-        and_raise(IOError)
+      expect(io).to receive(:write).exactly(3).times.with(record.message)
+                                   .and_raise(IOError)
 
       expect do
-        Steno::Sink::IO.new(io, :codec => codec, :max_retries => 2).
-          add_record(record)
+        Steno::Sink::IO.new(io, codec: codec, max_retries: 2)
+                       .add_record(record)
       end.to raise_error(IOError)
     end
 
-    it "should retry on IOError and succeed" do
-      codec = double("codec")
-      codec.should_receive(:encode_record).with(record).and_return(record.message)
+    it 'retries on IOError and succeed' do
+      codec = double('codec')
+      expect(codec).to receive(:encode_record).with(record).and_return(record.message)
 
-      io = double("io")
-      io.should_receive(:write).with(record.message).once.
-        and_raise(IOError)
-      io.should_receive(:write).with(record.message).once.ordered.
-        and_return(record.message)
+      io = double('io')
+      expect(io).to receive(:write).with(record.message).once
+                                   .and_raise(IOError)
+      expect(io).to receive(:write).with(record.message).once.ordered
+                                   .and_return(record.message)
 
       expect do
-        Steno::Sink::IO.new(io, :codec => codec, :max_retries => 1).
-          add_record(record)
-      end.to_not raise_error(IOError)
+        Steno::Sink::IO.new(io, codec: codec, max_retries: 1)
+                       .add_record(record)
+      end.not_to raise_error
     end
   end
 
-  describe "#flush" do
-    it "should call flush on the underlying io object" do
-      io = double("io")
-      io.should_receive(:flush)
+  describe '#flush' do
+    it 'calls flush on the underlying io object' do
+      io = double('io')
+      expect(io).to receive(:flush)
 
       Steno::Sink::IO.new(io).flush
     end

data/spec/unit/sink/syslog_spec.rb

@@ -1,4 +1,4 @@
-require "spec_helper"
+require 'spec_helper'
 unless Steno::Sink::WINDOWS
   describe Steno::Sink::Syslog do
     let(:level) do
@@ -6,68 +6,92 @@ unless Steno::Sink::WINDOWS
     end
 
     let(:record) do
-      Steno::Record.new("source", level.name, "message")
+      Steno::Record.new('source', level.name, 'message')
     end
 
     let(:record_with_big_message) do
-      Steno::Record.new("source", level.name,
-                        "a" * (Steno::Sink::Syslog::MAX_MESSAGE_SIZE + 1))
+      Steno::Record.new('source', level.name,
+                        'a' * (Steno::Sink::Syslog::MAX_MESSAGE_SIZE + 1))
     end
 
-    describe "#add_record" do
-      it "should append an encoded record with the correct priority" do
-        identity = "test"
+    describe '#add_record' do
+      after do
+        Syslog::Logger.syslog = nil
+      end
+
+      it 'appends an encoded record with the correct priority' do
+        identity = 'test'
 
-        syslog = double("syslog")
-        Syslog.should_receive(:open) \
-            .with(identity, Syslog::LOG_PID, Syslog::LOG_USER) \
-            .and_return(syslog)
+        syslog = double('syslog', facility: nil)
+        expect(Syslog).to receive(:open).and_return(syslog)
 
         sink = Steno::Sink::Syslog.instance
         sink.open(identity)
 
-        codec = double("codec")
-        codec.should_receive(:encode_record).with(record).and_return(record.message)
+        codec = double('codec')
+        expect(codec).to receive(:encode_record).with(record).and_return(record.message)
         sink.codec = codec
 
-        syslog.should_receive(:log).with(Syslog::LOG_INFO, "%s", record.message)
+        expect(syslog).to receive(:log).with(Syslog::LOG_INFO, '%s', record.message)
 
         sink.add_record(record)
       end
 
-      it "should truncate the record message if its greater than than allowed size" do
-        identity = "test"
+      it 'truncates the record message if its greater than than allowed size' do
+        identity = 'test'
 
-        syslog = double("syslog")
-        Syslog.should_receive(:open) \
-            .with(identity, Syslog::LOG_PID, Syslog::LOG_USER) \
-            .and_return(syslog)
+        syslog = double('syslog', facility: nil)
+        expect(Syslog).to receive(:open).and_return(syslog)
 
         sink = Steno::Sink::Syslog.instance
         sink.open(identity)
 
-        truncated = record_with_big_message.message.
-            slice(0..(Steno::Sink::Syslog::MAX_MESSAGE_SIZE) - 4)
+        truncated = record_with_big_message.message
+                                           .slice(0..Steno::Sink::Syslog::MAX_MESSAGE_SIZE - 4)
         truncated << Steno::Sink::Syslog::TRUNCATE_POSTFIX
-        codec = double("codec")
-        codec.should_receive(:encode_record) do |*args|
-          args.size.should == 1
-          args[0].message.should == truncated
-          args[0].message.size.should <= Steno::Sink::Syslog::MAX_MESSAGE_SIZE
+        codec = double('codec')
+        expect(codec).to receive(:encode_record) do |*args|
+          expect(args.size).to eq(1)
+          expect(args[0].message).to eq(truncated)
+          expect(args[0].message.size).to be <= Steno::Sink::Syslog::MAX_MESSAGE_SIZE
 
           next args[0].message
         end
 
         sink.codec = codec
 
-        syslog.should_receive(:log).with(Syslog::LOG_INFO, "%s", truncated)
+        expect(syslog).to receive(:log).with(Syslog::LOG_INFO, '%s', truncated)
 
         sink.add_record(record_with_big_message)
       end
+
+      context 'when level is off' do
+        let(:level) do
+          Steno::Logger.lookup_level(:off)
+        end
+
+        it 'does not write out logs' do
+          identity = 'test'
+
+          syslog = double('syslog', facility: nil, log: nil)
+          expect(Syslog).to receive(:open).and_return(syslog)
+
+          sink = Steno::Sink::Syslog.instance
+          sink.open(identity)
+
+          codec = double('codec', encode_record: nil)
+          sink.codec = codec
+
+          sink.add_record(record)
+
+          expect(codec).not_to have_received(:encode_record)
+          expect(syslog).not_to have_received(:log)
+        end
+      end
     end
 
-    describe "#flush" do
-      it "should do nothing" do
+    describe '#flush' do
+      it 'does nothing' do
         Steno::Sink::Syslog.instance.flush
       end
     end

data/spec/unit/steno_spec.rb

@@ -1,77 +1,77 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Steno do
   let(:config) { Steno::Config.new }
 
-  before :each do
+  before do
     Steno.init(config)
   end
 
-  describe "#logger" do
-    it "should return a new Steno::Logger instance" do
-      logger = Steno.logger("test")
-      logger.should_not be_nil
-      logger.name.should == "test"
+  describe '#logger' do
+    it 'returns a new Steno::Logger instance' do
+      logger = Steno.logger('test')
+      expect(logger).not_to be_nil
+      expect(logger.name).to eq('test')
     end
 
-    it "should memoize loggers by name" do
-      logger1 = Steno.logger("test")
-      logger2 = Steno.logger("test")
+    it 'memoizes loggers by name' do
+      logger1 = Steno.logger('test')
+      logger2 = Steno.logger('test')
 
-      logger1.object_id.should == logger2.object_id
+      expect(logger1.object_id).to eq(logger2.object_id)
     end
   end
 
-  describe "#set_logger_regexp" do
-    it "should modify the levels of existing loggers that match the regex" do
-      logger = Steno.logger("test")
+  describe '#set_logger_regexp' do
+    it 'modifies the levels of existing loggers that match the regex' do
+      logger = Steno.logger('test')
 
-      logger.level.should == :info
+      expect(logger.level).to eq(:info)
 
       Steno.set_logger_regexp(/te/, :debug)
 
-      logger.level.should == :debug
+      expect(logger.level).to eq(:debug)
     end
 
-    it "should modify the levels of new loggers after a regexp has been set" do
+    it 'modifies the levels of new loggers after a regexp has been set' do
       Steno.set_logger_regexp(/te/, :debug)
 
-      Steno.logger("te").level.should == :debug
+      expect(Steno.logger('te').level).to eq(:debug)
     end
 
-    it "should reset the levels of previously matching loggers when changed" do
+    it 'resets the levels of previously matching loggers when changed' do
       Steno.set_logger_regexp(/foo/, :debug)
 
-      logger = Steno.logger("foo")
-      logger.level.should == :debug
+      logger = Steno.logger('foo')
+      expect(logger.level).to eq(:debug)
 
       Steno.set_logger_regexp(/bar/, :debug)
 
-      logger.level.should == :info
+      expect(logger.level).to eq(:info)
     end
   end
 
-  describe "#clear_logger_regexp" do
-    it "should reset any loggers matching the existing regexp" do
+  describe '#clear_logger_regexp' do
+    it 'resets any loggers matching the existing regexp' do
       Steno.set_logger_regexp(/te/, :debug)
 
-      logger = Steno.logger("test")
-      logger.level.should == :debug
+      logger = Steno.logger('test')
+      expect(logger.level).to eq(:debug)
 
       Steno.clear_logger_regexp
 
-      logger.level.should == :info
-      Steno.logger_regexp.should be_nil
+      expect(logger.level).to eq(:info)
+      expect(Steno.logger_regexp).to be_nil
     end
   end
 
-  describe "#logger_level_snapshot" do
-    it "should return a hash mapping logger name to level" do
+  describe '#logger_level_snapshot' do
+    it 'returns a hash mapping logger name to level' do
       loggers = []
 
       expected = {
-        "foo" => :debug,
-        "bar" => :warn,
+        'foo' => :debug,
+        'bar' => :warn
       }
 
       expected.each do |name, level|
@@ -80,7 +80,7 @@ describe Steno do
         loggers.last.level = level
       end
 
-      Steno.logger_level_snapshot.should == expected
+      expect(Steno.logger_level_snapshot).to eq(expected)
     end
   end
 end

data/spec/unit/tagged_logger_spec.rb

@@ -1,33 +1,35 @@
+require 'spec_helper'
+
 describe Steno::TaggedLogger do
   let(:sink) { NullSink.new }
-  let(:logger) { Steno::Logger.new("test", [sink]) }
-  let(:user_data) { { "foo" => "bar" } }
+  let(:logger) { Steno::Logger.new('test', [sink]) }
+  let(:user_data) { { 'foo' => 'bar' } }
   let(:tagged_logger) { Steno::TaggedLogger.new(logger, user_data) }
 
-  it "should add any user data to each log record" do
-    tagged_logger.info("testing", "test" => "data")
-    sink.records.size.should == 1
-    sink.records[0].data.should == user_data.merge("test" => "data")
+  it 'adds any user data to each log record' do
+    tagged_logger.info('testing', 'test' => 'data')
+    expect(sink.records.size).to eq(1)
+    expect(sink.records[0].data).to eq(user_data.merge('test' => 'data'))
 
-    tagged_logger.log_exception(RuntimeError.new("hi"))
-    sink.records.size.should == 2
-    sink.records[1].data.should == user_data.merge(:backtrace => nil)
+    tagged_logger.log_exception(RuntimeError.new('hi'))
+    expect(sink.records.size).to eq(2)
+    expect(sink.records[1].data).to eq(user_data.merge(backtrace: nil))
   end
 
-  it "should forward missing methods to the proxied logger" do
-    tagged_logger.level.should == :info
+  it 'forwards missing methods to the proxied logger' do
+    expect(tagged_logger.level).to eq(:info)
     tagged_logger.level = :warn
 
-    logger.level.should == :warn
+    expect(logger.level).to eq(:warn)
 
-    tagged_logger.level_active?(:info).should be_false
+    expect(tagged_logger.level_active?(:info)).to be_falsey
   end
 
-  describe "#tag" do
-    it "should return a new tagged logger with merged user-data" do
-      tl = tagged_logger.tag("bar" => "baz")
-      tl.proxied_logger.should == logger
-      tl.user_data.should == user_data.merge("bar" => "baz")
+  describe '#tag' do
+    it 'returns a new tagged logger with merged user-data' do
+      tl = tagged_logger.tag('bar' => 'baz')
+      expect(tl.proxied_logger).to eq(logger)
+      expect(tl.user_data).to eq(user_data.merge('bar' => 'baz'))
     end
   end
 end

data/steno.gemspec

@@ -1,40 +1,40 @@
-# -*- encoding: utf-8 -*-
-require File.expand_path('../lib/steno/version', __FILE__)
+require File.expand_path('lib/steno/version', __dir__)
 
 Gem::Specification.new do |gem|
-  gem.authors       = ["mpage"]
-  gem.email         = ["mpage@rbcon.com"]
-  gem.description   = "A thread-safe logging library designed to support" \
-                      + " multiple log destinations."
-  gem.summary       = "A logging library."
-  gem.homepage      = "http://www.cloudfoundry.org"
+  gem.authors       = ['mpage']
+  gem.email         = ['mpage@rbcon.com']
+  gem.description   = 'A thread-safe logging library designed to support' \
+                      + ' multiple log destinations.'
+  gem.summary       = 'A logging library.'
+  gem.homepage      = 'http://www.cloudfoundry.org'
 
-  gitignore = File.readlines(".gitignore").grep(/^[^#]/).map { |s| s.chomp }
+  gitignore = File.readlines('.gitignore').grep(/^[^#]/).map { |s| s.chomp }
 
   # Ignore Gemfile, this is a library
-  gitignore << "Gemfile*"
+  gitignore << 'Gemfile*'
 
-  glob = Dir["**/*"].
-    reject { |f| File.directory?(f) }.
-    reject { |f| gitignore.any? { |i| File.fnmatch(i, f) } }
+  glob = Dir['**/*']
+         .reject { |f| File.directory?(f) }
+         .reject { |f| gitignore.any? { |i| File.fnmatch(i, f) } }
 
   gem.files         = glob
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.name          = "steno"
-  gem.require_paths = ["lib"]
+  gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
+  gem.name          = 'steno'
+  gem.require_paths = ['lib']
   gem.version       = Steno::VERSION
 
-  gem.add_dependency("yajl-ruby", "~> 1.0")
-  gem.add_dependency("fluent-logger")
-  
-  gem.add_development_dependency("ci_reporter")
-  gem.add_development_dependency("rack-test")
-  gem.add_development_dependency("rake")
-  gem.add_development_dependency("rspec")
-  
-  if RUBY_PLATFORM=~ /mswin|mingw|cygwin/
-    gem.platform      = Gem::Platform::CURRENT
-    gem.add_dependency("win32-eventlog", "~> 0.6.0")
+  gem.add_dependency('fluent-logger')
+  gem.add_dependency('yajl-ruby', '~> 1.0')
+
+  gem.add_development_dependency('rack-test')
+  gem.add_development_dependency('rake')
+  gem.add_development_dependency('rspec', '~>3.13.0')
+  gem.add_development_dependency('rubocop', '~> 1.62.0')
+  gem.add_development_dependency('rubocop-rake', '~> 0.6.0')
+  gem.add_development_dependency('rubocop-rspec', '~> 2.27.0')
+
+  if RUBY_PLATFORM =~ /mswin|mingw|cygwin/
+    gem.platform = Gem::Platform::CURRENT
+    gem.add_dependency('win32-eventlog', '~> 0.6.0')
   end
 end