steno 1.2.4 → 1.3.5

data/spec/unit/config_spec.rb

@@ -1,221 +1,222 @@
-require "fileutils"
-require "yaml"
+require 'fileutils'
+require 'yaml'
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Steno::Config do
-
   if Steno::Sink::WINDOWS
-    describe ".from_hash" do
-      before :each 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,
-                                                       :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()
-        .and_return(@mock_sink_eventlog)
+    describe '.from_hash' do
+      before do
+        @log_path = 'some_file'
+
+        @mock_sink_file = double('sink')
+        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')
+        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
+      after 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 contain_exactly(@mock_sink_file, @mock_sink_eventlog)
       end
 
-      it "should work for symbolized keys" do
+      it 'works for symbolized keys' do
         @hash = {
-            :file => @log_path,
-            :level => "debug2",
-            :default_log_level => "warn",
-            :eventlog => "test",
-            :max_retries => 5,
+          file: @log_path,
+          level: 'debug2',
+          default_log_level: 'warn',
+          eventlog: 'test',
+          max_retries: 5
         }
       end
 
-      it "should work for non-symbolized keys" do
+      it 'works for non-symbolized keys' do
         @hash = {
-            "file" => @log_path,
-            "level" => "debug2",
-            "default_log_level" => "warn",
-            "eventlog" => "test",
-            "max_retries" => 5,
+          'file' => @log_path,
+          'level' => 'debug2',
+          'default_log_level' => 'warn',
+          'eventlog' => 'test',
+          'max_retries' => 5
         }
       end
-
     end
   else
-    describe ".from_hash" do
-      before :each 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,
-                                                       :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()
-        .and_return(@mock_sink_syslog)
+    describe '.from_hash' do
+      before do
+        @log_path = 'some_file'
+
+        @mock_sink_file = double('sink')
+        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')
+        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
+      after 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 contain_exactly(@mock_sink_file, @mock_sink_syslog)
       end
 
-      it "should work for symbolized keys" do
+      it 'works for symbolized keys' do
         @hash = {
-            :file => @log_path,
-            :level => "debug2",
-            :default_log_level => "warn",
-            :syslog => "test",
-            :max_retries => 5,
+          file: @log_path,
+          level: 'debug2',
+          default_log_level: 'warn',
+          syslog: 'test',
+          max_retries: 5
         }
       end
 
-      it "should work for non-symbolized keys" do
+      it 'works for non-symbolized keys' do
         @hash = {
-            "file" => @log_path,
-            "level" => "debug2",
-            "default_log_level" => "warn",
-            "syslog" => "test",
-            "max_retries" => 5,
+          'file' => @log_path,
+          'level' => 'debug2',
+          'default_log_level' => 'warn',
+          'syslog' => 'test',
+          'max_retries' => 5
         }
       end
-
     end
   end
 
-  describe ".from_file" do
-    before :each do
+  describe '.from_file' do
+    before do
       @tmpdir = Dir.mktmpdir
-      @config_path = File.join(@tmpdir, "config.yml")
-      @log_path = File.join(@tmpdir, "test.log")
+      @config_path = File.join(@tmpdir, 'config.yml')
+      @log_path = File.join(@tmpdir, 'test.log')
     end
 
-    after :each do
+    after do
       FileUtils.rm_rf(@tmpdir)
     end
 
-    it "should return Steno::Config instance with sane defaults" do
+    it 'returns Steno::Config instance with sane defaults' do
       write_config(@config_path, {})
 
       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 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
+    it 'configures 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
 
-      write_config(@config_path, {"default_log_level" => "debug2"})
-      Steno::Config.from_file(@config_path).default_log_level.should == :debug2
+    it 'sets the default_log_level if a key with the same name is supplied' do
+      write_config(@config_path, { 'level' => 'debug2' })
+      expect(Steno::Config.from_file(@config_path).default_log_level).to eq(:debug2)
+
+      write_config(@config_path, { 'default_log_level' => '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
+    it "reads the 'level' key if both default_log_level and level are spscified" do
+      write_config(@config_path, { 'level' => 'debug2',
+                                   'default_log_level' => 'warn' })
+      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=)
+    it "adds a file sink if the 'file' key is specified" do
+      write_config(@config_path, { 'file' => @log_path, 'max_retries' => 2 })
+      mock_sink = double('sink')
+      expect(mock_sink).to receive(:codec=)
 
-      Steno::Sink::IO.should_receive(:for_file).
-          with(@log_path, :max_retries => 2).and_return(mock_sink)
+      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=)
+      it "adds a event sink if the 'eventlog' key is specified" do
+        write_config(@config_path, { 'eventlog' => 'test' })
+        mock_sink = double('sink')
+        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=)
+      it "adds a syslog sink if the 'syslog' key is specified" do
+        write_config(@config_path, { 'syslog' => 'test' })
+        mock_sink = double('sink')
+        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
 
-
-
-    it "should add an io sink to stdout if no sinks are explicitly specified in the config file" do
+    it 'adds 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=)
+      mock_sink = double('sink')
+      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
-      write_config(@config_path, {"default_log_level" => "debug"})
+    it 'merges supplied overrides with the file based config' do
+      write_config(@config_path, { 'default_log_level' => 'debug' })
 
       context = Steno::Context::ThreadLocal.new
       config = Steno::Config.from_file(@config_path,
-                                       :default_log_level => "warn",
-                                       :context => context)
-      config.context.should == context
-      config.default_log_level.should == :warn
+                                       default_log_level: 'warn',
+                                       context: context)
+      expect(config.context).to eq(context)
+      expect(config.default_log_level).to eq(:warn)
     end
   end
 
   def write_config(path, config)
-    File.open(path, "w+") do |f|
-      f.write(YAML.dump({"logging" => config}))
-    end
+    File.write(path, YAML.dump({ 'logging' => config }))
   end
 end

data/spec/unit/context_spec.rb

@@ -1,37 +1,37 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Steno::Context::Null do
-  include_context :steno_context
+  include_context 'steno context'
 
   let(:context) { Steno::Context::Null.new }
 
-  it "should store no data" do
-    context.data.should == {}
-    context.data["foo"] = "bar"
-    context.data.should == {}
+  it 'stores no data' do
+    expect(context.data).to eq({})
+    context.data['foo'] = 'bar'
+    expect(context.data).to eq({})
   end
 end
 
 describe Steno::Context::ThreadLocal do
-  include_context :steno_context
+  include_context 'steno context'
 
-  let (:context) { Steno::Context::ThreadLocal.new }
+  let(:context) { Steno::Context::ThreadLocal.new }
 
-  it "should store data local to threads" do
+  it 'stores data local to threads' do
     b1 = Barrier.new
     b2 = Barrier.new
 
     t1 = Thread.new do
-      context.data["thread"] = "t1"
+      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
-      context.data["thread"] = "t2"
+      expect(context.data['thread']).to be_nil
+      context.data['thread'] = 't2'
       b2.release
     end
 
@@ -41,20 +41,20 @@ describe Steno::Context::ThreadLocal do
 end
 
 describe Steno::Context::FiberLocal do
-  include_context :steno_context
+  include_context 'steno context'
 
   let(:context) { Steno::Context::FiberLocal.new }
 
-  it "should store data local to fibers" do
+  it 'stores data local to fibers' do
     f2 = Fiber.new do
-      context.data["fiber"].should be_nil
-      context.data["fiber"] = "f2"
+      expect(context.data['fiber']).to be_nil
+      context.data['fiber'] = 'f2'
     end
 
     f1 = Fiber.new do
-      context.data["fiber"] = "f1"
+      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

@@ -1,6 +1,6 @@
-require "spec_helper"
+require 'spec_helper'
 
-require "steno/core_ext"
+require 'steno/core_ext'
 
 module Foo
   class Bar
@@ -8,31 +8,31 @@ module Foo
 end
 
 describe Module do
-  describe "#logger" do
-    it "should request a logger named after itself" do
+  describe '#logger' do
+    it 'requests 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
 
 describe Class do
-  describe "#logger" do
-    it "should request a logger named after itself" do
+  describe '#logger' do
+    it 'requests 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
 
 describe Object do
-  describe "#logger" do
-    it "should request a logger named after its class" do
+  describe '#logger' do
+    it 'requests 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

@@ -1,48 +1,68 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Steno::Codec::Json do
   let(:codec) { Steno::Codec::Json.new }
-  let(:record) { make_record(:data => { "user" => "data" }) }
+  let(:record) { make_record(data: { 'user' => 'data' }) }
 
-  describe "#encode_record" do
-    it "should encode records as json hashes" do
+  describe '#encode_record' do
+    it 'encodes 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
+    it 'encodes 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/)
+    it 'escapes newlines' do
+      rec = make_record(message: "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/)
+    it 'escapes carriage returns' do
+      rec = make_record(message: "newline\rtest")
+      expect(codec.encode_record(rec)).to match(/newline\\rtest/)
     end
 
-    it "should allow messages with valid encodings to pass through untouched" do
+    it 'allows messages with valid encodings to pass through untouched' do
       msg = "HI\u2600"
-      rec = make_record(:message => msg)
-      codec.encode_record(rec).should match(/#{msg}/)
+      rec = make_record(message: 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/)
+    it 'treats messages with invalid encodings as binary data' do
+      msg = "HI\u2026".force_encoding('US-ASCII')
+      rec = make_record(message: msg)
+      expect(codec.encode_record(rec)).to match(/HI\\\\xe2\\\\x80\\\\xa6/)
+    end
+
+    it 'does not 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 'encodes timestamps as UTC-formatted strings' do
+        allow(record).to receive(:timestamp).and_return 1_396_473_763.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 'surfaces the property in a getter' do
+        expect(codec.iso8601_timestamps?).to eq(true)
+      end
     end
   end
 
   def make_record(opts = {})
-    Steno::Record.new(opts[:source]  || "my_source",
+    Steno::Record.new(opts[:source]  || 'my_source',
                       opts[:level]   || :debug,
-                      opts[:message] || "test message",
+                      opts[:message] || 'test message',
                       nil,
-                      opts[:data]    || {})
+                      opts[:data] || {})
   end
 end