steno 1.3.4 → 1.3.5

data/spec/unit/logger_spec.rb

@@ -1,40 +1,40 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Steno::Logger do
-  let(:logger) { Steno::Logger.new("test", []) }
+  let(:logger) { Steno::Logger.new('test', []) }
 
-  it "should provide #level, #levelf, and #level? methods for each log level" do
+  it 'provides #level, #levelf, and #level? methods for each log level' do
     Steno::Logger::LEVELS.each do |name, _|
-      [name, name.to_s + "f", name.to_s + "?"].each do |meth|
+      [name, name.to_s + 'f', name.to_s + '?'].each do |meth|
         expect(logger.respond_to?(meth)).to be_truthy
       end
     end
   end
 
-  describe "#level_active?" do
-    it "should return a boolean indicating if the level is enabled" do
+  describe '#level_active?' do
+    it 'returns a boolean indicating if the level is enabled' do
       expect(logger.level_active?(:error)).to be_truthy
       expect(logger.level_active?(:info)).to be_truthy
       expect(logger.level_active?(:debug)).to be_falsey
     end
   end
 
-  describe "#<level>?" do
-    it "should return a boolean indiciating if <level> is enabled" do
+  describe '#<level>?' do
+    it 'returns a boolean indiciating if <level> is enabled' do
       expect(logger.error?).to be_truthy
       expect(logger.info?).to be_truthy
       expect(logger.debug?).to be_falsey
     end
   end
 
-  describe "#level" do
-    it "should return the name of the currently active level" do
+  describe '#level' do
+    it 'returns the name of the currently active level' do
       expect(logger.level).to eq(:info)
     end
   end
 
-  describe "#level=" do
-    it "should allow the level to be changed" do
+  describe '#level=' do
+    it 'allows the level to be changed' do
       logger.level = :warn
       expect(logger.level).to eq(:warn)
       expect(logger.level_active?(:info)).to be_falsey
@@ -42,60 +42,60 @@ describe Steno::Logger do
     end
   end
 
-  describe "#log" do
-    it "should not forward any messages for levels that are inactive" do
-      sink = double("sink")
-      expect(sink).to_not receive(:add_record)
+  describe '#log' do
+    it 'does not forward any messages for levels that are inactive' do
+      sink = double('sink')
+      expect(sink).not_to receive(:add_record)
 
-      my_logger = Steno::Logger.new("test", [sink])
+      my_logger = Steno::Logger.new('test', [sink])
 
-      my_logger.debug("test")
+      my_logger.debug('test')
     end
 
-    it "should forward messages for levels that are active" do
-      sink = double("sink")
-      expect(sink).to receive(:add_record).with(any_args())
+    it 'forwards messages for levels that are active' do
+      sink = double('sink')
+      expect(sink).to receive(:add_record).with(any_args)
 
-      my_logger = Steno::Logger.new("test", [sink])
+      my_logger = Steno::Logger.new('test', [sink])
 
-      my_logger.warn("test")
+      my_logger.warn('test')
     end
 
-    it "should not invoke a supplied block if the level is inactive" do
+    it 'does not invoke a supplied block if the level is inactive' do
       invoked = false
       logger.debug { invoked = true }
       expect(invoked).to be_falsey
     end
 
-    it "should invoke a supplied block if the level is active" do
+    it 'invokes a supplied block if the level is active' do
       invoked = false
       logger.warn { invoked = true }
       expect(invoked).to be_truthy
     end
 
-    it "creates a record with the proper level" do
-      sink = double("sink")
-      expect(Steno::Record).to receive(:new).with("test", :warn, "message", anything, anything).and_call_original
+    it 'creates a record with the proper level' do
+      sink = double('sink')
+      expect(Steno::Record).to receive(:new).with('test', :warn, 'message', anything, anything).and_call_original
       allow(sink).to receive(:add_record)
 
-      my_logger = Steno::Logger.new("test", [sink])
+      my_logger = Steno::Logger.new('test', [sink])
 
-      my_logger.warn("message")
+      my_logger.warn('message')
     end
   end
 
-  describe "#logf" do
-    it "should format messages according to the supplied format string" do
-      expect(logger).to receive(:log).with(:debug, "test 1 2.20")
-      logger.debugf("test %d %0.2f", 1, 2.2)
+  describe '#logf' do
+    it 'formats messages according to the supplied format string' do
+      expect(logger).to receive(:log).with(:debug, 'test 1 2.20')
+      logger.debugf('test %d %0.2f', 1, 2.2)
     end
   end
 
-  describe "#tag" do
-    it "should return a tagged logger" do
-      tagged_logger = logger.tag("foo" => "bar")
-      expect(tagged_logger).to_not be_nil
-      expect(tagged_logger.user_data).to eq({ "foo" => "bar" })
+  describe '#tag' do
+    it 'returns a tagged logger' do
+      tagged_logger = logger.tag('foo' => 'bar')
+      expect(tagged_logger).not_to be_nil
+      expect(tagged_logger.user_data).to eq({ 'foo' => 'bar' })
     end
   end
 end

data/spec/unit/record_spec.rb

@@ -1,30 +1,30 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Steno::Record do
-  let(:message) { Array("test message") }
-  let(:record) { Steno::Record.new("test", :info, message) }
+  let(:message) { Array('test message') }
+  let(:record) { Steno::Record.new('test', :info, message) }
 
-  it "should set the process id" do
+  it 'sets the process id' do
     expect(record.process_id).to eq(Process.pid)
   end
 
-  it "should set the thread id" do
+  it 'sets the thread id' do
     expect(record.thread_id).to eq(Thread.current.object_id)
   end
 
-  it "should set the fiber id(if available)", :needs_fibers => true do
+  it 'sets the fiber id(if available)', :needs_fibers do
     expect(record.fiber_id).to eq(Fiber.current.object_id)
   end
 
-  it "should set the source" do
-    expect(record.source).to eq("test")
+  it 'sets the source' do
+    expect(record.source).to eq('test')
   end
 
-  it "should stringify the message" do
+  it 'stringifies the message' do
     expect(record.message).to be_a(String)
   end
 
-  it "should use a UTC timestamp" do
+  it 'uses a UTC timestamp' do
     expect(record.timestamp.to_f).to be_within(0.1).of(Time.now.utc.to_f)
   end
 end

data/spec/unit/sink/counter_spec.rb

@@ -1,4 +1,4 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Steno::Sink::Counter do
   let(:level) do
@@ -6,11 +6,11 @@ describe Steno::Sink::Counter do
   end
 
   let(:record) do
-    Steno::Record.new("source", level.name, "message")
+    Steno::Record.new('source', level.name, 'message')
   end
 
-  describe "add_record" do
-    it "counts added records" do
+  describe 'add_record' do
+    it 'counts added records' do
       expect(subject.counts).to be_empty
       subject.add_record(record)
       expect(subject.counts.size).to eq 1
@@ -18,10 +18,10 @@ describe Steno::Sink::Counter do
     end
   end
 
-  describe "to_json" do
-    it "produces a valid json representation" do
+  describe 'to_json' do
+    it 'produces a valid json representation' do
       subject.add_record(record)
       expect(subject.to_json).to match '"info":1'
     end
   end
-end
+end

data/spec/unit/sink/eventlog_spec.rb

@@ -1,4 +1,4 @@
-require "spec_helper"
+require 'spec_helper'
 if Steno::Sink::WINDOWS
   describe Steno::Sink::Eventlog do
     let(:level) do
@@ -6,34 +6,33 @@ if Steno::Sink::WINDOWS
     end
 
     let(:record) do
-      Steno::Record.new("source", level.name, "message")
+      Steno::Record.new('source', level.name, 'message')
     end
 
-    describe "#add_record" do
-
-      it "should append an encoded record with the correct priority" do
-        eventlog = double("Win32::EventLog")
-        Win32::EventLog.should_receive(:open) \
-            .with('Application') \
-            .and_return(eventlog)
+    describe '#add_record' do
+      it 'appends an encoded record with the correct priority' do
+        eventlog = double('Win32::EventLog')
+        Win32::EventLog.should_receive(:open)
+                       .with('Application')
+                       .and_return(eventlog)
 
         sink = Steno::Sink::Eventlog.instance
         sink.open
 
-        codec = double("codec")
+        codec = double('codec')
         codec.should_receive(:encode_record).with(record).and_return(record.message)
         sink.codec = codec
 
-        eventlog.should_receive(:report_event).with(:source      => "CloudFoundry",
-                                                    :event_type  => Win32::EventLog::INFO_TYPE,
-                                                    :data        => record.message)
+        eventlog.should_receive(:report_event).with(source: 'CloudFoundry',
+                                                    event_type: Win32::EventLog::INFO_TYPE,
+                                                    data: record.message)
 
         sink.add_record(record)
       end
     end
 
-    describe "#flush" do
-      it "should do nothing" do
+    describe '#flush' do
+      it 'does nothing' do
         Steno::Sink::Eventlog.instance.flush
       end
     end

data/spec/unit/sink/fluentd_spec.rb

@@ -1,4 +1,4 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Steno::Sink::IO do
   let(:level) do
@@ -6,40 +6,40 @@ 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 "#initialize" do
-    it "should initialize FluentLogger with the default option" do
-      expect(Fluent::Logger::FluentLogger).to receive(:new).with("steno", {
-        :host => "127.0.0.1",
-        :port => 24224,
-        :buffer_limit => Fluent::Logger::FluentLogger::BUFFER_LIMIT,
-        }).and_return(nil)
-      sink = Steno::Sink::Fluentd.new()
+  describe '#initialize' do
+    it 'initializes FluentLogger with the default option' do
+      expect(Fluent::Logger::FluentLogger).to receive(:new).with('steno', {
+                                                                   host: '127.0.0.1',
+                                                                   port: 24_224,
+                                                                   buffer_limit: Fluent::Logger::FluentLogger::BUFFER_LIMIT
+                                                                 }).and_return(nil)
+      sink = Steno::Sink::Fluentd.new
     end
 
-    it "should initialize FliuentLogger with override options" do
-      expect(Fluent::Logger::FluentLogger).to receive(:new).with("vcap", {
-        :host => "localhost",
-        :port => 8080,
-        :buffer_limit => 1024,
-        }).and_return(nil)
+    it 'initializes FliuentLogger with override options' do
+      expect(Fluent::Logger::FluentLogger).to receive(:new).with('vcap', {
+                                                                   host: 'localhost',
+                                                                   port: 8080,
+                                                                   buffer_limit: 1024
+                                                                 }).and_return(nil)
       sink = Steno::Sink::Fluentd.new({
-        :tag_prefix => "vcap",
-        :host => "localhost",
-        :port => 8080,
-        :buffer_limit => 1024
-        })
+                                        tag_prefix: 'vcap',
+                                        host: 'localhost',
+                                        port: 8080,
+                                        buffer_limit: 1024
+                                      })
     end
   end
 
-  describe "#add_record" do
-    it "should post an record with the correct tag" do
-      fluentd = double("fluentd")
+  describe '#add_record' do
+    it 'posts an record with the correct tag' do
+      fluentd = double('fluentd')
       expect(Fluent::Logger::FluentLogger).to receive(:new).and_return(fluentd)
-      expect(fluentd).to receive(:post).with("source", record)
-      sink = Steno::Sink::Fluentd.new()
+      expect(fluentd).to receive(:post).with('source', record)
+      sink = Steno::Sink::Fluentd.new
       sink.add_record(record)
     end
   end

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,103 +6,103 @@ 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')
 
-      expect(File).to receive(:open).with("path", "a+").and_return(mock_handle)
+      expect(File).to receive(:open).with('path', 'a+').and_return(mock_handle)
       expect(mock_handle).to receive(:sync=).with(true)
 
-      mock_sink = double("sink")
+      mock_sink = double('sink')
       expect(Steno::Sink::IO).to receive(:new).with(mock_handle,
-                                                :max_retries => 10).
-        and_return(mock_sink)
+                                                    max_retries: 10)
+                                              .and_return(mock_sink)
 
-      returned = Steno::Sink::IO.for_file("path",
-                                          :max_retries => 10)
+      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')
 
-      expect(File).to receive(:open).with("path", "a+").and_return(mock_handle)
+      expect(File).to receive(:open).with('path', 'a+').and_return(mock_handle)
       expect(mock_handle).to receive(:sync=).with(false)
 
-      mock_sink = double("sink")
+      mock_sink = double('sink')
       expect(Steno::Sink::IO).to receive(:new).with(mock_handle,
-                                                :max_retries => 10).
-        and_return(mock_sink)
+                                                    max_retries: 10)
+                                              .and_return(mock_sink)
 
-      returned = Steno::Sink::IO.for_file("path",
-                                          :autoflush => false,
-                                          :max_retries => 10)
+      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")
+  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 = 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")
+    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')
 
       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")
+    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')
 
-      expect(io).to 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")
+    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")
-      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)
+      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
+        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")
+  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

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,50 +6,50 @@ 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
+    describe '#add_record' do
       after do
         Syslog::Logger.syslog = nil
       end
 
-      it "should append an encoded record with the correct priority" do
-        identity = "test"
+      it 'appends an encoded record with the correct priority' do
+        identity = 'test'
 
-        syslog = double("syslog", facility: nil)
+        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 = double('codec')
         expect(codec).to receive(:encode_record).with(record).and_return(record.message)
         sink.codec = codec
 
-        expect(syslog).to 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", facility: nil)
+        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 = double('codec')
         expect(codec).to receive(:encode_record) do |*args|
           expect(args.size).to eq(1)
           expect(args[0].message).to eq(truncated)
@@ -60,14 +60,38 @@ unless Steno::Sink::WINDOWS
 
         sink.codec = codec
 
-        expect(syslog).to 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