steno 1.2.4 → 1.3.4

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    MmJiYWIyYzUzZjdlZjk2YzIwY2Q3ZDk5YTY4NTgxYzE4OWQ4MGJiZA==
-  data.tar.gz: !binary |-
-    MzUzMjIwZTNjYTAzYWIyZDE2MmNmNTNiOTBkMzIzZmRiMDJmMGFkOQ==
+SHA1:
+  metadata.gz: 9ae74f2bde35a6d8f17503cb1cd7bff4eb458b78
+  data.tar.gz: a3939b000fb9d0aaf3c7ade1231008d24e212a6e
 SHA512:
-  metadata.gz: !binary |-
-    ZGM2OWU1ZGZlYmEyZTVlODMyYzJiZDU5ZDliMWI0ZjExNWMwYzFmODU5NmNl
-    ZDRlYjY5NzEzMjA5NmI0NTQwMmE0MjBiNDBkNTc2NDQ2ZGIxZTVkNDhhNzA2
-    MDFiNWMxMjhhOTA2YzUyYzMxN2ZhMzk1YjZlYmIzYjdkZDk2ZjM=
-  data.tar.gz: !binary |-
-    Zjc3ZmVkY2QzNWZjZDUxYWNiYWQ5MWRhYjlkNjM2ZTg1Nzc0MDBhNWNlZWY4
-    ZDUzYjg1YWJiZDUxYzlkN2E0ZDg1NTk5YzMwMzdiMzRkMGZhNDdhOTMyMWUw
-    ZDE0YTVmNTBkZWI1MmNjNGEyNjgyOWI1YWQyYTRkNjgzNTFhZWY=
+  metadata.gz: c12db2c17088b015b24cbb6744d66b9ad7880a93c302b2dd16a0f7d896c38342677cf935f9b478f66c0d93988677bda9611c865af2a6aaa4baedb91bd88f3d1c
+  data.tar.gz: 23b73d7a6eb69d64d1e33292ba3a97ae5a5dcc617e9d09112a2e0e03c74abbfd941909a3622b120832ade5e9ee80aa35fe8f7dbe3fcc74cde74c864aa5c7f5f0

data/Rakefile

@@ -1,5 +1,4 @@
 #!/usr/bin/env rake
-require "ci/reporter/rake/rspec"
 require "rspec/core/rake_task"
 
 task :default => :spec

data/lib/steno/codec/json.rb

@@ -8,6 +8,11 @@ module Steno
 end
 
 class Steno::Codec::Json < Steno::Codec::Base
+
+  def initialize(opts = {})
+    @iso8601_timestamps = opts[:iso8601_timestamps] || false
+  end
+
   def encode_record(record)
     msg =
       if record.message.valid_encoding?
@@ -31,6 +36,14 @@ class Steno::Codec::Json < Steno::Codec::Base
       "method"     => record.method,
     }
 
-    Yajl::Encoder.encode(h) + "\n"
+    if iso8601_timestamps?
+      h["timestamp"] = Time.at(record.timestamp).utc.iso8601(6)
+    end
+
+     Yajl::Encoder.encode(h) + "\n"
+  end
+
+  def iso8601_timestamps?
+    @iso8601_timestamps
   end
 end

data/lib/steno/config.rb

@@ -41,6 +41,10 @@ class Steno::Config
         :default_log_level => level.nil? ? :info : level.to_sym
       }
 
+      if hash[:iso8601_timestamps]
+        opts[:codec] = Steno::Codec::Json.new(:iso8601_timestamps => true)
+      end
+
       if hash[:file]
         max_retries = hash[:max_retries]
         opts[:sinks] << Steno::Sink::IO.for_file(hash[:file], :max_retries => max_retries)

data/lib/steno/json_prettifier.rb

@@ -50,7 +50,7 @@ class Steno::JsonPrettifier
 
       exists = nil
       pred_meth = "check_#{field_name}".to_sym
-      if respond_to?(pred_meth)
+      if respond_to?(pred_meth, true)
         exists = send(pred_meth, record)
       elsif record.respond_to?(:has_key?)
         exists = record.has_key?(field_name)

data/lib/steno/sink/syslog.rb

@@ -3,7 +3,7 @@ unless Steno::Sink::WINDOWS
 
   require "singleton"
   require "thread"
-  require "syslog"
+  require "syslog/logger"
 
   class Steno::Sink::Syslog < Steno::Sink::Base
     include Singleton
@@ -30,7 +30,9 @@ unless Steno::Sink::WINDOWS
 
     def open(identity)
       @identity = identity
-      @syslog = Syslog.open(@identity, Syslog::LOG_PID, Syslog::LOG_USER)
+
+      Syslog::Logger.new(@identity)
+      @syslog = Syslog::Logger.syslog
     end
 
     def add_record(record)
@@ -57,4 +59,4 @@ unless Steno::Sink::WINDOWS
                         record.data)
     end
   end
-end
+end

data/lib/steno/version.rb

@@ -1,3 +1,3 @@
 module Steno
-  VERSION = "1.2.4"
+  VERSION = "1.3.4"
 end

data/spec/support/shared_context_specs.rb

@@ -2,6 +2,6 @@ shared_context :steno_context do
   it "should support clearing context local data" do
     context.data["test"] = "value"
     context.clear
-    context.data["test"].should be_nil
+    expect(context.data["test"]).to be_nil
   end
 end

data/spec/unit/config_spec.rb

@@ -11,27 +11,27 @@ describe Steno::Config do
         @log_path = "some_file"
 
         @mock_sink_file = double("sink")
-        @mock_sink_file.stub(:codec=)
-        Steno::Sink::IO.should_receive(:for_file).with(@log_path,
+        expect(@mock_sink_file).to receive(:codec=)
+        expect(Steno::Sink::IO).to receive(:for_file).with(@log_path,
                                                        :max_retries => 5)
         .and_return(@mock_sink_file)
 
         @mock_sink_eventlog = double("sink")
-        @mock_sink_eventlog.stub(:codec=)
-        @mock_sink_eventlog.should_receive(:open).with("test")
-        Steno::Sink::Eventlog.should_receive(:instance).twice()
+        expect(@mock_sink_eventlog).to receive(:codec=)
+        expect(@mock_sink_eventlog).to receive(:open).with("test")
+        expect(Steno::Sink::Eventlog).to receive(:instance).twice()
         .and_return(@mock_sink_eventlog)
       end
 
       after :each do
         @config = Steno::Config.from_hash(@hash)
 
-        @config.default_log_level.should == :debug2
-        @config.context.should.class == Steno::Context::Null
-        @config.codec.should.class == Steno::Codec::Json
+        expect(@config.default_log_level).to eq(:debug2)
+        expect(@config.context.class).to eq(Steno::Context::Null)
+        expect(@config.codec.class).to eq(Steno::Codec::Json)
 
-        @config.sinks.size.should == 2
-        @config.sinks.should =~ [@mock_sink_file, @mock_sink_eventlog]
+        expect(@config.sinks.size).to eq(2)
+        expect(@config.sinks).to match_array([@mock_sink_file, @mock_sink_eventlog])
       end
 
       it "should work for symbolized keys" do
@@ -61,27 +61,27 @@ describe Steno::Config do
         @log_path = "some_file"
 
         @mock_sink_file = double("sink")
-        @mock_sink_file.stub(:codec=)
-        Steno::Sink::IO.should_receive(:for_file).with(@log_path,
+        allow(@mock_sink_file).to receive(:codec=)
+        expect(Steno::Sink::IO).to receive(:for_file).with(@log_path,
                                                        :max_retries => 5)
         .and_return(@mock_sink_file)
 
         @mock_sink_syslog = double("sink")
-        @mock_sink_syslog.stub(:codec=)
-        @mock_sink_syslog.should_receive(:open).with("test")
-        Steno::Sink::Syslog.should_receive(:instance).twice()
+        expect(@mock_sink_syslog).to receive(:codec=)
+        expect(@mock_sink_syslog).to receive(:open).with("test")
+        expect(Steno::Sink::Syslog).to receive(:instance).twice()
         .and_return(@mock_sink_syslog)
       end
 
       after :each do
         @config = Steno::Config.from_hash(@hash)
 
-        @config.default_log_level.should == :debug2
-        @config.context.should.class == Steno::Context::Null
-        @config.codec.should.class == Steno::Codec::Json
+        expect(@config.default_log_level).to eq(:debug2)
+        expect(@config.context.class).to eq(Steno::Context::Null)
+        expect(@config.codec.class).to eq(Steno::Codec::Json)
 
-        @config.sinks.size.should == 2
-        @config.sinks.should =~ [@mock_sink_file, @mock_sink_syslog]
+        expect(@config.sinks.size).to eq(2)
+        expect(@config.sinks).to match_array([@mock_sink_file, @mock_sink_syslog])
       end
 
       it "should work for symbolized keys" do
@@ -123,67 +123,75 @@ describe Steno::Config do
 
       config = Steno::Config.from_file(@config_path)
 
-      config.sinks.size.should == 1
-      config.sinks[0].class.should == Steno::Sink::IO
+      expect(config.sinks.size).to eq(1)
+      expect(config.sinks[0].class).to eq(Steno::Sink::IO)
 
-      config.default_log_level.should == :info
+      expect(config.default_log_level).to eq(:info)
 
-      config.context.should.class == Steno::Context::Null
+      expect(config.context.class).to eq(Steno::Context::Null)
 
-      config.codec.should.class == Steno::Codec::Json
+      expect(config.codec.class).to eq(Steno::Codec::Json)
+      expect(config.codec.iso8601_timestamps?).to eq(false)
+    end
+
+    it "should configure json codec with readable dates if iso8601_timestamps is true" do
+      write_config(@config_path, {"iso8601_timestamps" => "true"})
+      config = Steno::Config.from_file(@config_path)
+      expect(config.codec.class).to eq(Steno::Codec::Json)
+      expect(config.codec.iso8601_timestamps?).to eq(true)
     end
 
     it "should set the default_log_level if a key with the same name is supplied" do
       write_config(@config_path, {"level" => "debug2"})
-      Steno::Config.from_file(@config_path).default_log_level.should == :debug2
+      expect(Steno::Config.from_file(@config_path).default_log_level).to eq(:debug2)
 
       write_config(@config_path, {"default_log_level" => "debug2"})
-      Steno::Config.from_file(@config_path).default_log_level.should == :debug2
+      expect(Steno::Config.from_file(@config_path).default_log_level).to eq(:debug2)
     end
 
     it "should read the 'level' key if both default_log_level and level are spscified" do
       write_config(@config_path, {"level" => "debug2",
                                   "default_log_level" => "warn"})
-      Steno::Config.from_file(@config_path).default_log_level.should == :debug2
+      expect(Steno::Config.from_file(@config_path).default_log_level).to eq(:debug2)
     end
 
     it "should add a file sink if the 'file' key is specified" do
       write_config(@config_path, {"file" => @log_path, "max_retries" => 2})
       mock_sink = double("sink")
-      mock_sink.stub(:codec=)
+      expect(mock_sink).to receive(:codec=)
 
-      Steno::Sink::IO.should_receive(:for_file).
+      expect(Steno::Sink::IO).to receive(:for_file).
           with(@log_path, :max_retries => 2).and_return(mock_sink)
       config = Steno::Config.from_file(@config_path)
-      config.sinks.size.should == 1
-      config.sinks[0].should == mock_sink
+      expect(config.sinks.size).to eq(1)
+      expect(config.sinks[0]).to eq(mock_sink)
     end
 
     if Steno::Sink::WINDOWS
       it "should add a event sink if the 'eventlog' key is specified" do
         write_config(@config_path, {"eventlog" => "test"})
         mock_sink = double("sink")
-        mock_sink.should_receive(:open).with("test")
-        mock_sink.stub(:codec=)
+        expect(mock_sink).to receive(:open).with("test")
+        expect(mock_sink).to receive(:codec=)
 
-        Steno::Sink::Eventlog.should_receive(:instance).twice().and_return(mock_sink)
+        expect(Steno::Sink::Eventlog).to receive(:instance).twice().and_return(mock_sink)
 
         config = Steno::Config.from_file(@config_path)
-        config.sinks.size.should == 1
-        config.sinks[0].should == mock_sink
+        expect(config.sinks.size).to eq(1)
+        expect(config.sinks[0]).to eq(mock_sink)
       end
     else
       it "should add a syslog sink if the 'syslog' key is specified" do
         write_config(@config_path, {"syslog" => "test"})
         mock_sink = double("sink")
-        mock_sink.should_receive(:open).with("test")
-        mock_sink.stub(:codec=)
+        expect(mock_sink).to receive(:open).with("test")
+        expect(mock_sink).to receive(:codec=)
 
-        Steno::Sink::Syslog.should_receive(:instance).twice().and_return(mock_sink)
+        expect(Steno::Sink::Syslog).to receive(:instance).twice().and_return(mock_sink)
 
         config = Steno::Config.from_file(@config_path)
-        config.sinks.size.should == 1
-        config.sinks[0].should == mock_sink
+        expect(config.sinks.size).to eq(1)
+        expect(config.sinks[0]).to eq(mock_sink)
       end
     end
 
@@ -192,13 +200,13 @@ describe Steno::Config do
     it "should add an io sink to stdout if no sinks are explicitly specified in the config file" do
       write_config(@config_path, {})
       mock_sink = double("sink")
-      mock_sink.stub(:codec=)
+      expect(mock_sink).to receive(:codec=)
 
-      Steno::Sink::IO.should_receive(:new).with(STDOUT).and_return(mock_sink)
+      expect(Steno::Sink::IO).to receive(:new).with(STDOUT).and_return(mock_sink)
 
       config = Steno::Config.from_file(@config_path)
-      config.sinks.size.should == 1
-      config.sinks[0].should == mock_sink
+      expect(config.sinks.size).to eq(1)
+      expect(config.sinks[0]).to eq(mock_sink)
     end
 
     it "should merge supplied overrides with the file based config" do
@@ -208,8 +216,8 @@ describe Steno::Config do
       config = Steno::Config.from_file(@config_path,
                                        :default_log_level => "warn",
                                        :context => context)
-      config.context.should == context
-      config.default_log_level.should == :warn
+      expect(config.context).to eq(context)
+      expect(config.default_log_level).to eq(:warn)
     end
   end
 

data/spec/unit/context_spec.rb

@@ -6,9 +6,9 @@ describe Steno::Context::Null do
   let(:context) { Steno::Context::Null.new }
 
   it "should store no data" do
-    context.data.should == {}
+    expect(context.data).to eq({})
     context.data["foo"] = "bar"
-    context.data.should == {}
+    expect(context.data).to eq({})
   end
 end
 
@@ -25,12 +25,12 @@ describe Steno::Context::ThreadLocal do
       context.data["thread"] = "t1"
       b1.release
       b2.wait
-      context.data["thread"].should == "t1"
+      expect(context.data["thread"]).to eq("t1")
     end
 
     t2 = Thread.new do
       b1.wait
-      context.data["thread"].should be_nil
+      expect(context.data["thread"]).to be_nil
       context.data["thread"] = "t2"
       b2.release
     end
@@ -47,14 +47,14 @@ describe Steno::Context::FiberLocal do
 
   it "should store data local to fibers" do
     f2 = Fiber.new do
-      context.data["fiber"].should be_nil
+      expect(context.data["fiber"]).to be_nil
       context.data["fiber"] = "f2"
     end
 
     f1 = Fiber.new do
       context.data["fiber"] = "f1"
       f2.resume
-      context.data["fiber"].should == "f1"
+      expect(context.data["fiber"]).to eq("f1")
     end
 
     f1.resume

data/spec/unit/core_ext_spec.rb

@@ -11,8 +11,8 @@ describe Module do
   describe "#logger" do
     it "should request a logger named after itself" do
       x = Foo.logger
-      x.should be_a(Steno::Logger)
-      x.name.should include("Foo")
+      expect(x).to be_a(Steno::Logger)
+      expect(x.name).to include("Foo")
     end
   end
 end
@@ -21,8 +21,8 @@ describe Class do
   describe "#logger" do
     it "should request a logger named after itself" do
       x = Foo::Bar.logger
-      x.should be_a(Steno::Logger)
-      x.name.should include("Foo::Bar")
+      expect(x).to be_a(Steno::Logger)
+      expect(x.name).to include("Foo::Bar")
     end
   end
 end
@@ -31,8 +31,8 @@ describe Object do
   describe "#logger" do
     it "should request a logger named after its class" do
       x = Foo::Bar.new.logger
-      x.should be_a(Steno::Logger)
-      x.name.should include("Foo::Bar")
+      expect(x).to be_a(Steno::Logger)
+      expect(x.name).to include("Foo::Bar")
     end
   end
 end

data/spec/unit/json_codec_spec.rb

@@ -7,34 +7,54 @@ describe Steno::Codec::Json do
   describe "#encode_record" do
     it "should encode records as json hashes" do
       parsed = Yajl::Parser.parse(codec.encode_record(record))
-      parsed.class.should == Hash
+      expect(parsed.class).to eq(Hash)
     end
 
     it "should encode the timestamp as a float" do
       parsed = Yajl::Parser.parse(codec.encode_record(record))
-      parsed["timestamp"].class.should == Float
+      expect(parsed["timestamp"].class).to eq(Float)
     end
 
     it "should escape newlines" do
       rec = make_record(:message => "newline\ntest")
-      codec.encode_record(rec).should match(/newline\\ntest/)
+      expect(codec.encode_record(rec)).to match(/newline\\ntest/)
     end
 
     it "should escape carriage returns" do
       rec = make_record(:message => "newline\rtest")
-      codec.encode_record(rec).should match(/newline\\rtest/)
+      expect(codec.encode_record(rec)).to match(/newline\\rtest/)
     end
 
     it "should allow messages with valid encodings to pass through untouched" do
       msg = "HI\u2600"
       rec = make_record(:message => msg)
-      codec.encode_record(rec).should match(/#{msg}/)
+      expect(codec.encode_record(rec)).to match(/#{msg}/)
     end
 
     it "should treat messages with invalid encodings as binary data" do
       msg = "HI\u2026".force_encoding("US-ASCII")
       rec = make_record(:message => msg)
-      codec.encode_record(rec).should match(/HI\\\\xe2\\\\x80\\\\xa6/)
+      expect(codec.encode_record(rec)).to match(/HI\\\\xe2\\\\x80\\\\xa6/)
+    end
+
+    it "shouldn't use readable dates by default" do
+      expect(codec.iso8601_timestamps?).to eq(false)
+    end
+
+    context "when iso8601_timestamps is set" do
+      let(:codec) { Steno::Codec::Json.new( :iso8601_timestamps => true ) }
+
+      it "should encode timestamps as UTC-formatted strings" do
+        allow(record).to receive(:timestamp).and_return 1396473763.811278 # 2014-04-02 22:22:43 +01:00
+        parsed = Yajl::Parser.parse(codec.encode_record(record))
+
+        expect(parsed["timestamp"].class).to eq(String)
+        expect(parsed["timestamp"]).to eq("2014-04-02T21:22:43.811278Z")
+      end
+
+      it "should surface the property in a getter" do
+        expect(codec.iso8601_timestamps?).to eq(true)
+      end
     end
   end
 

data/spec/unit/json_prettifier_spec.rb

@@ -25,7 +25,7 @@ describe Steno::JsonPrettifier do
                    '--',
                    'message',                  # Log message
                    ].join("\s+") + "\n"
-      prettified.should match(exp_regex)
+      expect(prettified).to match(exp_regex)
     end
 
     it "should always use the largest src len to determine src column width" do
@@ -60,7 +60,7 @@ describe Steno::JsonPrettifier do
         src_col = prettified.match(regex)[1]
 
         max_src_len = [max_src_len, src.length].max
-        src_col.length.should == max_src_len
+        expect(src_col.length).to eq(max_src_len)
       end
     end
 
@@ -77,8 +77,8 @@ describe Steno::JsonPrettifier do
     end
 
     it "should work with a nil data field" do
-      line = prettifier.prettify_line(%@{"data":null}@)
-      line.should include(" - ")
+      line = prettifier.prettify_line('{"data":null}')
+      expect(line).to include(" - ")
     end
   end
 end

data/spec/unit/log_level_spec.rb

@@ -5,14 +5,14 @@ describe Steno::LogLevel do
   let(:debug_level) { Steno::LogLevel.new(:debug, 1) }
 
   it "should be comparable" do
-    (info_level > debug_level).should be_true
-    (debug_level > info_level).should be_false
-    (info_level == info_level).should be_true
+    expect(info_level > debug_level).to be_truthy
+    expect(debug_level > info_level).to be_falsey
+    expect(info_level == info_level).to be_truthy
   end
 
   describe "#to_s" do
     it "should return the name of the level" do
-      info_level.to_s.should == "info"
+      expect(info_level.to_s).to eq("info")
     end
   end
 

data/spec/unit/logger_spec.rb

@@ -6,46 +6,46 @@ describe Steno::Logger do
   it "should provide #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|
-        logger.respond_to?(meth).should be_true
+        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
-      logger.level_active?(:error).should be_true
-      logger.level_active?(:info).should be_true
-      logger.level_active?(:debug).should be_false
+      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
-      logger.error?.should be_true
-      logger.info?.should be_true
-      logger.debug?.should be_false
+      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
-      logger.level.should == :info
+      expect(logger.level).to eq(:info)
     end
   end
 
   describe "#level=" do
     it "should allow the level to be changed" do
       logger.level = :warn
-      logger.level.should == :warn
-      logger.level_active?(:info).should be_false
-      logger.level_active?(:warn).should be_true
+      expect(logger.level).to eq(:warn)
+      expect(logger.level_active?(:info)).to be_falsey
+      expect(logger.level_active?(:warn)).to be_truthy
     end
   end
 
   describe "#log" do
     it "should not forward any messages for levels that are inactive" do
       sink = double("sink")
-      sink.should_not_receive(:add_record)
+      expect(sink).to_not receive(:add_record)
 
       my_logger = Steno::Logger.new("test", [sink])
 
@@ -54,7 +54,7 @@ describe Steno::Logger do
 
     it "should forward messages for levels that are active" do
       sink = double("sink")
-      sink.should_receive(:add_record).with(any_args())
+      expect(sink).to receive(:add_record).with(any_args())
 
       my_logger = Steno::Logger.new("test", [sink])
 
@@ -64,19 +64,19 @@ describe Steno::Logger do
     it "should not invoke a supplied block if the level is inactive" do
       invoked = false
       logger.debug { invoked = true }
-      invoked.should be_false
+      expect(invoked).to be_falsey
     end
 
     it "should invoke a supplied block if the level is active" do
       invoked = false
       logger.warn { invoked = true }
-      invoked.should be_true
+      expect(invoked).to be_truthy
     end
 
     it "creates a record with the proper level" do
       sink = double("sink")
-      Steno::Record.should_receive(:new).with("test", :warn, "message", anything, anything).and_call_original
-      sink.stub(:add_record)
+      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])
 
@@ -86,7 +86,7 @@ describe Steno::Logger do
 
   describe "#logf" do
     it "should format messages according to the supplied format string" do
-      logger.should_receive(:log).with(:debug, "test 1 2.20")
+      expect(logger).to receive(:log).with(:debug, "test 1 2.20")
       logger.debugf("test %d %0.2f", 1, 2.2)
     end
   end
@@ -94,8 +94,8 @@ describe Steno::Logger do
   describe "#tag" do
     it "should return a tagged logger" do
       tagged_logger = logger.tag("foo" => "bar")
-      tagged_logger.should_not be_nil
-      tagged_logger.user_data.should == { "foo" => "bar" }
+      expect(tagged_logger).to_not be_nil
+      expect(tagged_logger.user_data).to eq({ "foo" => "bar" })
     end
   end
 end

data/spec/unit/record_spec.rb

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

data/spec/unit/sink/fluentd_spec.rb

@@ -11,20 +11,20 @@ describe Steno::Sink::IO do
 
   describe "#initialize" do
     it "should initialize FluentLogger with the default option" do
-      Fluent::Logger::FluentLogger.should_receive(:new).with("steno", {
+      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()
+        }).and_return(nil)
       sink = Steno::Sink::Fluentd.new()
     end
 
     it "should initialize FliuentLogger with override options" do
-      Fluent::Logger::FluentLogger.should_receive(:new).with("vcap", {
+      expect(Fluent::Logger::FluentLogger).to receive(:new).with("vcap", {
         :host => "localhost",
         :port => 8080,
         :buffer_limit => 1024,
-        }).and_return()
+        }).and_return(nil)
       sink = Steno::Sink::Fluentd.new({
         :tag_prefix => "vcap",
         :host => "localhost",
@@ -37,10 +37,10 @@ describe Steno::Sink::IO do
   describe "#add_record" do
     it "should post an record with the correct tag" do
       fluentd = double("fluentd")
-      Fluent::Logger::FluentLogger.should_receive(:new).and_return(fluentd)
-      fluentd.should_receive(:post).with("source", record)
+      expect(Fluent::Logger::FluentLogger).to receive(:new).and_return(fluentd)
+      expect(fluentd).to receive(:post).with("source", record)
       sink = Steno::Sink::Fluentd.new()
       sink.add_record(record)
     end
   end
-end
+end

data/spec/unit/sink/io_spec.rb

@@ -13,55 +13,55 @@ describe Steno::Sink::IO 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")
 
-      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,
+      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
+      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")
 
-      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,
+      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
+      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)
+      expect(codec).to receive(:encode_record).with(record).and_return(record.message)
 
       io = double("io")
-      io.should_receive(:write).with(record.message)
+      expect(io).to receive(:write).with(record.message)
 
       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)
+      expect(codec).to receive(:encode_record).with(record).and_return(record.message)
 
       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)
@@ -70,11 +70,11 @@ describe Steno::Sink::IO do
 
     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)
+      expect(codec).to receive(:encode_record).with(record).and_return(record.message)
 
       io = double("io")
 
-      io.should_receive(:write).exactly(3).times.with(record.message).
+      expect(io).to receive(:write).exactly(3).times.with(record.message).
         and_raise(IOError)
 
       expect do
@@ -85,25 +85,25 @@ describe Steno::Sink::IO do
 
     it "should retry on IOError and succeed" do
       codec = double("codec")
-      codec.should_receive(:encode_record).with(record).and_return(record.message)
+      expect(codec).to receive(:encode_record).with(record).and_return(record.message)
 
       io = double("io")
-      io.should_receive(:write).with(record.message).once.
+      expect(io).to receive(:write).with(record.message).once.
         and_raise(IOError)
-      io.should_receive(:write).with(record.message).once.ordered.
+      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)
+      end.to_not raise_error
     end
   end
 
   describe "#flush" do
     it "should call flush on the underlying io object" do
       io = double("io")
-      io.should_receive(:flush)
+      expect(io).to receive(:flush)
 
       Steno::Sink::IO.new(io).flush
     end

data/spec/unit/sink/syslog_spec.rb

@@ -11,26 +11,28 @@ unless Steno::Sink::WINDOWS
 
     let(:record_with_big_message) do
       Steno::Record.new("source", level.name,
-                        "a" * (Steno::Sink::Syslog::MAX_MESSAGE_SIZE + 1))
+        "a" * (Steno::Sink::Syslog::MAX_MESSAGE_SIZE + 1))
     end
 
     describe "#add_record" do
+      after do
+        Syslog::Logger.syslog = nil
+      end
+
       it "should append 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)
+        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
@@ -38,10 +40,8 @@ unless Steno::Sink::WINDOWS
       it "should truncate 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)
@@ -50,17 +50,17 @@ unless Steno::Sink::WINDOWS
             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
+        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

data/spec/unit/steno_spec.rb

@@ -10,15 +10,15 @@ describe Steno do
   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"
+      expect(logger).to_not be_nil
+      expect(logger.name).to eq("test")
     end
 
     it "should memoize 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
 
@@ -26,28 +26,28 @@ describe Steno do
     it "should modify 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
       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
       Steno.set_logger_regexp(/foo/, :debug)
 
       logger = Steno.logger("foo")
-      logger.level.should == :debug
+      expect(logger.level).to eq(:debug)
 
       Steno.set_logger_regexp(/bar/, :debug)
 
-      logger.level.should == :info
+      expect(logger.level).to eq(:info)
     end
   end
 
@@ -56,12 +56,12 @@ describe Steno do
       Steno.set_logger_regexp(/te/, :debug)
 
       logger = Steno.logger("test")
-      logger.level.should == :debug
+      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
 
@@ -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,3 +1,5 @@
+require 'spec_helper'
+
 describe Steno::TaggedLogger do
   let(:sink) { NullSink.new }
   let(:logger) { Steno::Logger.new("test", [sink]) }
@@ -6,28 +8,28 @@ describe Steno::TaggedLogger do
 
   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")
+    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)
+    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
+    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")
+      expect(tl.proxied_logger).to eq(logger)
+      expect(tl.user_data).to eq(user_data.merge("bar" => "baz"))
     end
   end
 end

data/steno.gemspec

@@ -28,10 +28,9 @@ Gem::Specification.new do |gem|
   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")
+  gem.add_development_dependency("rspec", "~>3.4.0")
   
   if RUBY_PLATFORM=~ /mswin|mingw|cygwin/
     gem.platform      = Gem::Platform::CURRENT

metadata

@@ -1,99 +1,85 @@
 --- !ruby/object:Gem::Specification
 name: steno
 version: !ruby/object:Gem::Version
-  version: 1.2.4
+  version: 1.3.4
 platform: ruby
 authors:
 - mpage
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-17 00:00:00.000000000 Z
+date: 2016-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: yajl-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
   name: fluent-logger
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: ci_reporter
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rack-test
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.4.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.4.0
 description: A thread-safe logging library designed to support multiple log destinations.
 email:
 - mpage@rbcon.com
@@ -156,17 +142,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: A logging library.