steno-capi 1.3.4

data/spec/unit/context_spec.rb

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

data/spec/unit/core_ext_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+require "steno/core_ext"
+
+module Foo
+  class Bar
+  end
+end
+
+describe Module do
+  describe "#logger" do
+    it "should request a logger named after itself" do
+      x = Foo.logger
+      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
+      x = Foo::Bar.logger
+      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
+      x = Foo::Bar.new.logger
+      expect(x).to be_a(Steno::Logger)
+      expect(x.name).to include("Foo::Bar")
+    end
+  end
+end

data/spec/unit/json_codec_spec.rb

@@ -0,0 +1,68 @@
+require "spec_helper"
+
+describe Steno::Codec::Json do
+  let(:codec) { Steno::Codec::Json.new }
+  let(:record) { make_record(:data => { "user" => "data" }) }
+
+  describe "#encode_record" do
+    it "should encode records as json hashes" do
+      parsed = Yajl::Parser.parse(codec.encode_record(record))
+      expect(parsed.class).to eq(Hash)
+    end
+
+    it "should encode the timestamp as a float" do
+      parsed = Yajl::Parser.parse(codec.encode_record(record))
+      expect(parsed["timestamp"].class).to eq(Float)
+    end
+
+    it "should escape 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")
+      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)
+      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)
+      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
+
+  def make_record(opts = {})
+    Steno::Record.new(opts[:source]  || "my_source",
+                      opts[:level]   || :debug,
+                      opts[:message] || "test message",
+                      nil,
+                      opts[:data]    || {})
+  end
+end

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"
+      expect(prettified).to 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
+        expect(src_col.length).to eq(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}')
+      expect(line).to 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
+    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
+      expect(info_level.to_s).to eq("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|
+        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
+      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
+      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
+      expect(logger.level).to eq(:info)
+    end
+  end
+
+  describe "#level=" do
+    it "should allow the level to be changed" do
+      logger.level = :warn
+      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")
+      expect(sink).to_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")
+      expect(sink).to 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 }
+      expect(invoked).to be_falsey
+    end
+
+    it "should invoke 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
+      allow(sink).to receive(: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
+      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" })
+    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
+    expect(record.process_id).to eq(Process.pid)
+  end
+
+  it "should set 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
+    expect(record.fiber_id).to eq(Fiber.current.object_id)
+  end
+
+  it "should set the source" do
+    expect(record.source).to eq("test")
+  end
+
+  it "should stringify the message" do
+    expect(record.message).to be_a(String)
+  end
+
+  it "should use 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

@@ -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_TYPE,
+                                                    :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