steno 1.2.2-x86-mingw32

data/spec/unit/json_prettifier_spec.rb

@@ -0,0 +1,84 @@
+require "spec_helper"
+
+require "steno/json_prettifier"
+
+describe Steno::JsonPrettifier do
+  let(:prettifier) { Steno::JsonPrettifier.new }
+  let(:codec) { Steno::Codec::Json.new }
+
+  describe "#prettify_line" do
+    it "should return a properly formatted string" do
+      record = Steno::Record.new("test", :info, "message",
+                                 ["filename", "line", "method"], "test" => "data")
+      encoded = codec.encode_record(record)
+      prettified = prettifier.prettify_line(encoded)
+
+      exp_regex = ['\d{4}-\d{2}-\d{2}',        # YYYY-MM-DD
+                   '\d{2}:\d{2}:\d{2}\.\d{6}', # HH:MM:SS.uS
+                   'test',                     # Source
+                   'pid=\d+',                  # Process id
+                   'tid=\w{4}',                # Thread shortid
+                   'fid=\w{4}',                # Fiber shortid
+                   'filename\/method:line',    # Location
+                   'test=data',                # User supplied data
+                   'INFO',                     # Level
+                   '--',
+                   'message',                  # Log message
+                   ].join("\s+") + "\n"
+      prettified.should match(exp_regex)
+    end
+
+    it "should always use the largest src len to determine src column width" do
+      test_srcs = [
+        'a' * (Steno::JsonPrettifier::MIN_COL_WIDTH - 3),
+        'a' * (Steno::JsonPrettifier::MIN_COL_WIDTH - 1),
+        'a' * (Steno::JsonPrettifier::MIN_COL_WIDTH),
+        'a' * (Steno::JsonPrettifier::MIN_COL_WIDTH + 1),
+        'a' * (Steno::JsonPrettifier::MIN_COL_WIDTH - 3),
+        'a' * (Steno::JsonPrettifier::MIN_COL_WIDTH + 3),
+        'a' * (Steno::JsonPrettifier::MIN_COL_WIDTH - 2),
+        'a' * (Steno::JsonPrettifier::MIN_COL_WIDTH + 2)
+      ]
+
+      regex = ['\d{4}-\d{2}-\d{2}',        # YYYY-MM-DD
+               '\d{2}:\d{2}:\d{2}\.\d{6}', # HH:MM:SS.uS
+               '([a-zA-Z0-9\ ]+)',         # Source (to be captured)
+               'pid=\d+',                  # Process id
+               '.+'                        # Everything else
+      ].join("\s") + "\n"
+
+      max_src_len = Steno::JsonPrettifier::MIN_COL_WIDTH
+      test_srcs.each do |src|
+        record = Steno::Record.new(src,
+                                   :info,
+                                   "message",
+                                   ["filename", "line", "method"],
+                                   "test" => "data")
+
+        encoded = codec.encode_record(record)
+        prettified = prettifier.prettify_line(encoded)
+        src_col = prettified.match(regex)[1]
+
+        max_src_len = [max_src_len, src.length].max
+        src_col.length.should == max_src_len
+      end
+    end
+
+    it "should raise a parse error when the json-encoded string is not a hash" do
+      expect {
+        prettifier.prettify_line("[1,2,3]")
+      }.to raise_error(Steno::JsonPrettifier::ParseError)
+    end
+
+    it "should raise a parse error when the json-encoded string is malformed" do
+      expect {
+        prettifier.prettify_line("blah")
+      }.to raise_error(Steno::JsonPrettifier::ParseError)
+    end
+
+    it "should work with a nil data field" do
+      line = prettifier.prettify_line(%@{"data":null}@)
+      line.should include(" - ")
+    end
+  end
+end

data/spec/unit/log_level_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+describe Steno::LogLevel do
+  let(:info_level) { Steno::LogLevel.new(:info, 2) }
+  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
+  end
+
+  describe "#to_s" do
+    it "should return the name of the level" do
+      info_level.to_s.should == "info"
+    end
+  end
+
+end

data/spec/unit/logger_spec.rb

@@ -0,0 +1,101 @@
+require "spec_helper"
+
+describe Steno::Logger do
+  let(:logger) { Steno::Logger.new("test", []) }
+
+  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
+      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
+    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
+    end
+  end
+
+  describe "#level" do
+    it "should return the name of the currently active level" do
+      logger.level.should == :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
+    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)
+
+      my_logger = Steno::Logger.new("test", [sink])
+
+      my_logger.debug("test")
+    end
+
+    it "should forward messages for levels that are active" do
+      sink = double("sink")
+      sink.should_receive(:add_record).with(any_args())
+
+      my_logger = Steno::Logger.new("test", [sink])
+
+      my_logger.warn("test")
+    end
+
+    it "should not invoke a supplied block if the level is inactive" do
+      invoked = false
+      logger.debug { invoked = true }
+      invoked.should be_false
+    end
+
+    it "should invoke a supplied block if the level is active" do
+      invoked = false
+      logger.warn { invoked = true }
+      invoked.should be_true
+    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)
+
+      my_logger = Steno::Logger.new("test", [sink])
+
+      my_logger.warn("message")
+    end
+  end
+
+  describe "#logf" do
+    it "should format messages according to the supplied format string" do
+      logger.should_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")
+      tagged_logger.should_not be_nil
+      tagged_logger.user_data.should == { "foo" => "bar" }
+    end
+  end
+end

data/spec/unit/record_spec.rb

@@ -0,0 +1,30 @@
+require "spec_helper"
+
+describe Steno::Record do
+  let(:message) { Array("test message") }
+  let(:record) { Steno::Record.new("test", :info, message) }
+
+  it "should set the process id" do
+    record.process_id.should == Process.pid
+  end
+
+  it "should set the thread id" do
+    record.thread_id.should == 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
+  end
+
+  it "should set the source" do
+    record.source.should == "test"
+  end
+
+  it "should stringify the message" do
+    record.message.should 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)
+  end
+end

data/spec/unit/sink/counter_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+describe Steno::Sink::Counter do
+  let(:level) do
+    Steno::Logger.lookup_level(:info)
+  end
+
+  let(:record) do
+    Steno::Record.new("source", level.name, "message")
+  end
+
+  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
+      expect(subject.counts['info']).to eq 1
+    end
+  end
+
+  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

data/spec/unit/sink/eventlog_spec.rb

@@ -0,0 +1,41 @@
+require "spec_helper"
+if Steno::Sink::WINDOWS
+  describe Steno::Sink::Eventlog do
+    let(:level) do
+      Steno::Logger.lookup_level(:info)
+    end
+
+    let(:record) do
+      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)
+
+        sink = Steno::Sink::Eventlog.instance
+        sink.open
+
+        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,
+                                                    :data        => record.message)
+
+        sink.add_record(record)
+      end
+    end
+
+    describe "#flush" do
+      it "should do nothing" do
+        Steno::Sink::Eventlog.instance.flush
+      end
+    end
+  end
+end

data/spec/unit/sink/fluentd_spec.rb

@@ -0,0 +1,46 @@
+require "spec_helper"
+
+describe Steno::Sink::IO do
+  let(:level) do
+    Steno::Logger.lookup_level(:info)
+  end
+
+  let(:record) do
+    Steno::Record.new("source", level.name, "message")
+  end
+
+  describe "#initialize" do
+    it "should initialize FluentLogger with the default option" do
+      Fluent::Logger::FluentLogger.should_receive(:new).with("steno", {
+        :host => "127.0.0.1",
+        :port => 24224,
+        :buffer_limit => Fluent::Logger::FluentLogger::BUFFER_LIMIT,
+        }).and_return()
+      sink = Steno::Sink::Fluentd.new()
+    end
+
+    it "should initialize FliuentLogger with override options" do
+      Fluent::Logger::FluentLogger.should_receive(:new).with("vcap", {
+        :host => "localhost",
+        :port => 8080,
+        :buffer_limit => 1024,
+        }).and_return()
+      sink = Steno::Sink::Fluentd.new({
+        :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")
+      Fluent::Logger::FluentLogger.should_receive(:new).and_return(fluentd)
+      fluentd.should_receive(:post).with("source", record)
+      sink = Steno::Sink::Fluentd.new()
+      sink.add_record(record)
+    end
+  end
+end

data/spec/unit/sink/io_spec.rb

@@ -0,0 +1,111 @@
+require "spec_helper"
+
+describe Steno::Sink::IO do
+  let(:level) do
+    Steno::Logger.lookup_level(:info)
+  end
+
+  let(:record) do
+    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")
+
+      File.should_receive(:open).with("path", "a+").and_return(mock_handle)
+      mock_handle.should_receive(:sync=).with(true)
+
+      mock_sink = double("sink")
+      Steno::Sink::IO.should_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
+    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)
+
+      mock_sink = double("sink")
+      Steno::Sink::IO.should_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
+    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)
+
+      io = double("io")
+      io.should_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)
+
+      io = double("io")
+
+      io.should_receive(:write).with(record.message).ordered.and_raise(IOError)
+
+      expect do
+        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)
+
+      io = double("io")
+
+      io.should_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)
+      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)
+
+      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)
+
+      expect do
+        Steno::Sink::IO.new(io, :codec => codec, :max_retries => 1).
+          add_record(record)
+      end.to_not raise_error(IOError)
+    end
+  end
+
+  describe "#flush" do
+    it "should call flush on the underlying io object" do
+      io = double("io")
+      io.should_receive(:flush)
+
+      Steno::Sink::IO.new(io).flush
+    end
+  end
+end