steno 1.2.2-x86-mingw32

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/config_spec.rb

@@ -0,0 +1,221 @@
+require "fileutils"
+require "yaml"
+
+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)
+      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
+
+        @config.sinks.size.should == 2
+        @config.sinks.should =~ [@mock_sink_file, @mock_sink_eventlog]
+      end
+
+      it "should work for symbolized keys" do
+        @hash = {
+            :file => @log_path,
+            :level => "debug2",
+            :default_log_level => "warn",
+            :eventlog => "test",
+            :max_retries => 5,
+        }
+      end
+
+      it "should work for non-symbolized keys" do
+        @hash = {
+            "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)
+      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
+
+        @config.sinks.size.should == 2
+        @config.sinks.should =~ [@mock_sink_file, @mock_sink_syslog]
+      end
+
+      it "should work for symbolized keys" do
+        @hash = {
+            :file => @log_path,
+            :level => "debug2",
+            :default_log_level => "warn",
+            :syslog => "test",
+            :max_retries => 5,
+        }
+      end
+
+      it "should work for non-symbolized keys" do
+        @hash = {
+            "file" => @log_path,
+            "level" => "debug2",
+            "default_log_level" => "warn",
+            "syslog" => "test",
+            "max_retries" => 5,
+        }
+      end
+
+    end
+  end
+
+  describe ".from_file" do
+    before :each do
+      @tmpdir = Dir.mktmpdir
+      @config_path = File.join(@tmpdir, "config.yml")
+      @log_path = File.join(@tmpdir, "test.log")
+    end
+
+    after :each do
+      FileUtils.rm_rf(@tmpdir)
+    end
+
+    it "should return 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
+
+      config.default_log_level.should == :info
+
+      config.context.should.class == Steno::Context::Null
+
+      config.codec.should.class == Steno::Codec::Json
+    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
+
+      write_config(@config_path, {"default_log_level" => "debug2"})
+      Steno::Config.from_file(@config_path).default_log_level.should == :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
+    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=)
+
+      Steno::Sink::IO.should_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
+    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=)
+
+        Steno::Sink::Eventlog.should_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
+      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=)
+
+        Steno::Sink::Syslog.should_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
+      end
+    end
+
+
+
+    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=)
+
+      Steno::Sink::IO.should_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
+    end
+
+    it "should merge 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
+    end
+  end
+
+  def write_config(path, config)
+    File.open(path, "w+") do |f|
+      f.write(YAML.dump({"logging" => config}))
+    end
+  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/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
+      x.should be_a(Steno::Logger)
+      x.name.should include("Foo")
+    end
+  end
+end
+
+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")
+    end
+  end
+end
+
+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")
+    end
+  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/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]   || :debug,
+                      opts[:message] || "test message",
+                      nil,
+                      opts[:data]    || {})
+  end
+end