steno 0.0.3

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require "rack/test"
+require "rspec"
+
+require "steno"
+
+Dir["./spec/support/**/*.rb"].each { |file| require file }

data/spec/support/barrier.rb

@@ -0,0 +1,22 @@
+require "thread"
+
+class Barrier
+  def initialize
+    @lock = Mutex.new
+    @cvar = ConditionVariable.new
+    @done = false
+  end
+
+  def release
+    @lock.synchronize do
+      @done = true
+      @cvar.broadcast
+    end
+  end
+
+  def wait
+    @lock.synchronize do
+      @cvar.wait(@lock) if !@done
+    end
+  end
+end

data/spec/support/null_sink.rb

@@ -0,0 +1,17 @@
+class NullSink
+  attr_accessor :records
+
+  def initialize
+    @records = []
+  end
+
+  def add_record(record)
+    @records << record
+
+    nil
+  end
+
+  def flush
+    nil
+  end
+end

data/spec/support/shared_context_specs.rb

@@ -0,0 +1,7 @@
+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
+  end
+end

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
+    context.data.should == {}
+    context.data["foo"] = "bar"
+    context.data.should == {}
+  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
+      context.data["thread"].should == "t1"
+    end
+
+    t2 = Thread.new do
+      b1.wait
+      context.data["thread"].should 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
+      context.data["fiber"].should be_nil
+      context.data["fiber"] = "f2"
+    end
+
+    f1 = Fiber.new do
+      context.data["fiber"] = "f1"
+      f2.resume
+      context.data["fiber"].should == "f1"
+    end
+
+    f1.resume
+  end
+end

data/spec/unit/http_handler_spec.rb

@@ -0,0 +1,73 @@
+require "spec_helper"
+
+require "steno/http_handler"
+
+describe Steno::HttpHandler do
+  include Rack::Test::Methods
+
+  let(:config) { Steno::Config.new }
+
+  before :each do
+    Steno.init(config)
+  end
+
+  def app
+    Steno::HttpHandler
+  end
+
+  describe "GET /loggers/levels" do
+    it "returns a hash of logger name to level" do
+      get "/loggers/levels"
+      json_body.should == {}
+
+      foo = Steno.logger("foo")
+      foo.level = :debug
+
+      bar = Steno.logger("bar")
+      bar.level = :info
+
+      get "/loggers/levels"
+      json_body.should == { "foo" => "debug", "bar" => "info" }
+    end
+  end
+
+  describe "PUT /loggers/levels" do
+    it "returns an error on missing parameters" do
+      put "/loggers/levels"
+      last_response.status.should == 400
+      json_body["error"].should match(/Missing query parameters/)
+
+      put "/loggers/levels", :regexp => "hi"
+      last_response.status.should == 400
+      json_body["error"].should match(/Missing query parameters/)
+
+      put "/loggers/levels", :level => "debug"
+      last_response.status.should == 400
+      json_body["error"].should match(/Missing query parameters/)
+    end
+
+    it "returns an error on invalid log levels" do
+      put "/loggers/levels", :regexp => "hi", :level => "foobar"
+      last_response.status.should == 400
+      json_body["error"].should match(/Unknown level/)
+    end
+
+    it "updates log levels for loggers whose name matches the regexp" do
+      foo = Steno.logger("foo")
+      foo.level = :debug
+
+      bar = Steno.logger("bar")
+      bar.level = :warn
+
+      put "/loggers/levels", :regexp => "f", :level => "error"
+      last_response.status.should == 200
+
+      foo.level.should == :error
+      bar.level.should == :warn
+    end
+  end
+
+  def json_body
+    Yajl::Parser.parse(last_response.body)
+  end
+end

data/spec/unit/io_sink_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+
+describe Steno::Sink::IO do
+  let(:record) { { :data => "test" } }
+
+  describe "#add_record" do
+    it "should encode the record and write it to the underlying io object" do
+      codec = mock("codec")
+      codec.should_receive(:encode_record).with(record).and_return(record[:data])
+
+      io = mock("io")
+      io.should_receive(:write).with(record[:data])
+
+      Steno::Sink::IO.new(io, codec).add_record(record)
+    end
+  end
+
+  describe "#flush" do
+    it "should call flush on the underlying io object" do
+      io = mock("io")
+      io.should_receive(:flush)
+
+      Steno::Sink::IO.new(io).flush
+    end
+  end
+end

data/spec/unit/json_codec_spec.rb

@@ -0,0 +1,48 @@
+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))
+      parsed.class.should == Hash
+    end
+
+    it "should encode the timestamp as a float" do
+      parsed = Yajl::Parser.parse(codec.encode_record(record))
+      parsed["timestamp"].class.should == Float
+    end
+
+    it "should escape newlines" do
+      rec = make_record(:message => "newline\ntest")
+      codec.encode_record(rec).should match(/newline\\ntest/)
+    end
+
+    it "should escape carriage returns" do
+      rec = make_record(:message => "newline\rtest")
+      codec.encode_record(rec).should 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}/)
+    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/)
+    end
+  end
+
+  def make_record(opts = {})
+    Steno::Record.new(opts[:source]  || "my_source",
+                      opts[:level]   || Steno::LogLevel.new("debug", 0),
+                      opts[:message] || "test message",
+                      nil,
+                      opts[:data]    || {})
+  end
+end

data/spec/unit/log_level_spec.rb

@@ -0,0 +1,18 @@
+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,91 @@
+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 = mock("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 = mock("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
+  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,21 @@
+require "spec_helper"
+
+describe Steno::Record do
+  let(:record) { Steno::Record.new("test", :info, "test 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
+end

data/spec/unit/steno_spec.rb

@@ -0,0 +1,86 @@
+require "spec_helper"
+
+describe Steno do
+  let(:config) { Steno::Config.new }
+
+  before :each do
+    Steno.init(config)
+  end
+
+  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"
+    end
+
+    it "should memoize loggers by name" do
+      logger1 = Steno.logger("test")
+      logger2 = Steno.logger("test")
+
+      logger1.object_id.should == logger2.object_id
+    end
+  end
+
+  describe "#set_logger_regexp" do
+    it "should modify the levels of existing loggers that match the regex" do
+      logger = Steno.logger("test")
+
+      logger.level.should == :info
+
+      Steno.set_logger_regexp(/te/, :debug)
+
+      logger.level.should == :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
+    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
+
+      Steno.set_logger_regexp(/bar/, :debug)
+
+      logger.level.should == :info
+    end
+  end
+
+  describe "#clear_logger_regexp" do
+    it "should reset any loggers matching the existing regexp" do
+      Steno.set_logger_regexp(/te/, :debug)
+
+      logger = Steno.logger("test")
+      logger.level.should == :debug
+
+      Steno.clear_logger_regexp
+
+      logger.level.should == :info
+      Steno.logger_regexp.should be_nil
+    end
+  end
+
+  describe "#logger_level_snapshot" do
+    it "should return a hash mapping logger name to level" do
+      loggers = []
+
+      expected = {
+        "foo" => :debug,
+        "bar" => :warn,
+      }
+
+      expected.each do |name, level|
+        # Prevent GC
+        loggers << Steno.logger(name)
+        loggers.last.level = level
+      end
+
+      Steno.logger_level_snapshot.should == expected
+    end
+  end
+end