logster 2.1.0 → 2.1.1

data/test/logster/test_base_store.rb

@@ -1,147 +1,147 @@
-require_relative '../test_helper'
-require 'logster/base_store'
-require 'logster/ignore_pattern'
-
-class TestBaseStore < Minitest::Test
-
-  def setup
-    @store = Logster::TestStore.new
-    @store.clear_all
-  end
-
-  def teardown
-    @store.clear_all
-  end
-
-  def test_report_skip_empty
-    @store.skip_empty = true
-    @store.report(Logger::WARN, "test", nil)
-    @store.report(Logger::WARN, "test", '')
-    @store.report(Logger::WARN, "test", "foo") #
-    @store.skip_empty = false
-    @store.report(Logger::WARN, "test", nil) #
-
-    assert_equal(2, @store.count)
-  end
-
-  def test_report_skip_level
-    @store.level = nil
-    @store.report(Logger::DEBUG, "test", "A") #
-    @store.level = Logger::WARN
-    @store.report(Logger::DEBUG, "test", "A")
-    @store.report(Logger::INFO, "test", "B")
-    @store.report(Logger::WARN, "test", "C") #
-    @store.report(Logger::ERROR, "test", "D") #
-    assert_equal(3, @store.count)
-  end
-
-  def test_report_skip_ignore
-    @store.report(Logger::WARN, "test", "Can't verify CSRF token authenticity")
-    @store.report(Logger::FATAL, "test", "ActiveRecord::RecordNotFound (Couldn't find Upload with 'id'=9947)")
-    @store.report(Logger::WARN, "test", "B")
-    @store.ignore = [
-        /^ActiveRecord::RecordNotFound \(Couldn't find Upload/,
-        /^Can't verify CSRF token authenticity/
-    ]
-    @store.report(Logger::WARN, "test", "Can't verify CSRF token authenticity")
-    @store.report(Logger::FATAL, "test", "ActiveRecord::RecordNotFound (Couldn't find Upload with 'id'=9947)")
-    @store.report(Logger::FATAL, "test", "ActiveRecord::RecordNotFound (Couldn't find Upload with 'id'=9489+78946947)")
-    @store.report(Logger::WARN, "test", "B")
-
-    assert_equal(4, @store.count)
-  end
-
-  def test_ignore_pattern_basic
-    @store.ignore = [
-        Logster::IgnorePattern.new(nil, username: 'CausingErrors')
-    ]
-    @store.report(Logger::WARN, "test", "Foobar") #
-    @store.report(Logger::WARN, "test", "Foobar", env: { username: 'CausingErrors' })
-    @store.report(Logger::WARN, "test", "Foobar", env: nil)
-    @store.report(Logger::WARN, "test", "Something Else", env: { username: 'CausingErrors' })
-    @store.report(Logger::WARN, "test", "Something Else", env: { 'username' => 'CausingErrors' })
-    @store.report(Logger::WARN, "test", "Something Else", env: { username: 'GoodPerson' }) #
-    @store.report(Logger::WARN, "test", "Can't verify CSRF token authenticity") #
-
-    assert_equal(4, @store.count)
-  end
-
-  def test_ignore_pattern_real
-    @store.ignore = [
-        /^ActionController::RoutingError \(No route matches/,
-        Logster::IgnorePattern.new("Can't verify CSRF token authenticity", REQUEST_URI: /\/trackback\/$/)
-    ]
-    # blocked
-    @store.report(Logger::WARN, "whatever", "Can't verify CSRF token authenticity",
-        env: {
-            HTTP_HOST: 'meta.discourse.org',
-            REQUEST_URI: '/t/use-more-standard-smiley-codes-instead-of-smile/1822/trackback/',
-            REQUEST_METHOD: 'POST',
-            HTTP_USER_AGENT: 'Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1)',
-            params: {
-                title: 'Something Spammy',
-                url: 'http://spam.example.net/whatever/spam.html',
-                excerpt: 'http://spam.example.com/pdf/blahblah.html free viagra',
-                blog_name: 'get free spam for cheap'
-            }
-        }
-    )
-    # logged
-    @store.report(Logger::WARN, "whatever", "Can't verify CSRF token authenticity",
-        env: {
-            HTTP_HOST: 'meta.discourse.org',
-            REQUEST_URI: '/session',
-            REQUEST_METHOD: 'POST',
-            HTTP_USER_AGENT: 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/35.0.1916.153 Safari/537.36',
-            params: {
-                username: 'user',
-                password: 'password',
-                form_authenticity_token: 'incorrect'
-            }
-        }
-    )
-    assert_equal(1, @store.count)
-  end
-
-  def test_timestamp
-    time = Time.now - 24 * 60 * 60
-    message = @store.report(Logger::WARN, "test", "B", timestamp: time)
-
-    assert_equal(time, message.timestamp)
-  end
-
-  def test_backtrace
-    # Create an error with a backtrace
-    error = TypeError.new
-    begin
-      raise error
-    rescue => e
-      error = e
-    end
-
-    # Backtrace can be passed via backtrace param or env
-    message = @store.report(Logger::WARN, "test", "A", backtrace: error.backtrace)
-    assert_equal(error.backtrace.join("\n"), message.backtrace)
-    message = @store.report(Logger::WARN, "test", "B", env: { backtrace: error.backtrace })
-    assert_equal(error.backtrace.join("\n"), message.backtrace)
-
-    # Via env takes priority
-    message = @store.report(Logger::WARN, "test", "C", backtrace: "Garbage", env: { backtrace: error.backtrace })
-    assert_equal(error.backtrace.join("\n"), message.backtrace)
-
-    # Backtrace is always a string
-    # Cannot do an equal assert here, because it uses `caller` when not provided
-    message = @store.report(Logger::WARN, "test", "D", backtrace: nil)
-    assert_kind_of(String, message.backtrace)
-    message = @store.report(Logger::WARN, "test", "E", env: { backtrace: nil })
-    assert_kind_of(String, message.backtrace)
-    message = @store.report(Logger::WARN, "test", "F", backtrace: nil, env: { backtrace: nil })
-    assert_kind_of(String, message.backtrace)
-    message = @store.report(Logger::WARN, "test", "G")
-    assert_kind_of(String, message.backtrace)
-
-    # Arrays are turned into strings via join \n
-    message = @store.report(Logger::WARN, "test", "H", backtrace: ["Foo", "Bar"])
-    assert_equal("Foo\nBar", message.backtrace)
-  end
-end
+require_relative '../test_helper'
+require 'logster/base_store'
+require 'logster/ignore_pattern'
+
+class TestBaseStore < Minitest::Test
+
+  def setup
+    @store = Logster::TestStore.new
+    @store.clear_all
+  end
+
+  def teardown
+    @store.clear_all
+  end
+
+  def test_report_skip_empty
+    @store.skip_empty = true
+    @store.report(Logger::WARN, "test", nil)
+    @store.report(Logger::WARN, "test", '')
+    @store.report(Logger::WARN, "test", "foo") #
+    @store.skip_empty = false
+    @store.report(Logger::WARN, "test", nil) #
+
+    assert_equal(2, @store.count)
+  end
+
+  def test_report_skip_level
+    @store.level = nil
+    @store.report(Logger::DEBUG, "test", "A") #
+    @store.level = Logger::WARN
+    @store.report(Logger::DEBUG, "test", "A")
+    @store.report(Logger::INFO, "test", "B")
+    @store.report(Logger::WARN, "test", "C") #
+    @store.report(Logger::ERROR, "test", "D") #
+    assert_equal(3, @store.count)
+  end
+
+  def test_report_skip_ignore
+    @store.report(Logger::WARN, "test", "Can't verify CSRF token authenticity")
+    @store.report(Logger::FATAL, "test", "ActiveRecord::RecordNotFound (Couldn't find Upload with 'id'=9947)")
+    @store.report(Logger::WARN, "test", "B")
+    @store.ignore = [
+        /^ActiveRecord::RecordNotFound \(Couldn't find Upload/,
+        /^Can't verify CSRF token authenticity/
+    ]
+    @store.report(Logger::WARN, "test", "Can't verify CSRF token authenticity")
+    @store.report(Logger::FATAL, "test", "ActiveRecord::RecordNotFound (Couldn't find Upload with 'id'=9947)")
+    @store.report(Logger::FATAL, "test", "ActiveRecord::RecordNotFound (Couldn't find Upload with 'id'=9489+78946947)")
+    @store.report(Logger::WARN, "test", "B")
+
+    assert_equal(4, @store.count)
+  end
+
+  def test_ignore_pattern_basic
+    @store.ignore = [
+        Logster::IgnorePattern.new(nil, username: 'CausingErrors')
+    ]
+    @store.report(Logger::WARN, "test", "Foobar") #
+    @store.report(Logger::WARN, "test", "Foobar", env: { username: 'CausingErrors' })
+    @store.report(Logger::WARN, "test", "Foobar", env: nil)
+    @store.report(Logger::WARN, "test", "Something Else", env: { username: 'CausingErrors' })
+    @store.report(Logger::WARN, "test", "Something Else", env: { 'username' => 'CausingErrors' })
+    @store.report(Logger::WARN, "test", "Something Else", env: { username: 'GoodPerson' }) #
+    @store.report(Logger::WARN, "test", "Can't verify CSRF token authenticity") #
+
+    assert_equal(4, @store.count)
+  end
+
+  def test_ignore_pattern_real
+    @store.ignore = [
+        /^ActionController::RoutingError \(No route matches/,
+        Logster::IgnorePattern.new("Can't verify CSRF token authenticity", REQUEST_URI: /\/trackback\/$/)
+    ]
+    # blocked
+    @store.report(Logger::WARN, "whatever", "Can't verify CSRF token authenticity",
+        env: {
+            HTTP_HOST: 'meta.discourse.org',
+            REQUEST_URI: '/t/use-more-standard-smiley-codes-instead-of-smile/1822/trackback/',
+            REQUEST_METHOD: 'POST',
+            HTTP_USER_AGENT: 'Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1)',
+            params: {
+                title: 'Something Spammy',
+                url: 'http://spam.example.net/whatever/spam.html',
+                excerpt: 'http://spam.example.com/pdf/blahblah.html free viagra',
+                blog_name: 'get free spam for cheap'
+            }
+        }
+    )
+    # logged
+    @store.report(Logger::WARN, "whatever", "Can't verify CSRF token authenticity",
+        env: {
+            HTTP_HOST: 'meta.discourse.org',
+            REQUEST_URI: '/session',
+            REQUEST_METHOD: 'POST',
+            HTTP_USER_AGENT: 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/35.0.1916.153 Safari/537.36',
+            params: {
+                username: 'user',
+                password: 'password',
+                form_authenticity_token: 'incorrect'
+            }
+        }
+    )
+    assert_equal(1, @store.count)
+  end
+
+  def test_timestamp
+    time = Time.now - 24 * 60 * 60
+    message = @store.report(Logger::WARN, "test", "B", timestamp: time)
+
+    assert_equal(time, message.timestamp)
+  end
+
+  def test_backtrace
+    # Create an error with a backtrace
+    error = TypeError.new
+    begin
+      raise error
+    rescue => e
+      error = e
+    end
+
+    # Backtrace can be passed via backtrace param or env
+    message = @store.report(Logger::WARN, "test", "A", backtrace: error.backtrace)
+    assert_equal(error.backtrace.join("\n"), message.backtrace)
+    message = @store.report(Logger::WARN, "test", "B", env: { backtrace: error.backtrace })
+    assert_equal(error.backtrace.join("\n"), message.backtrace)
+
+    # Via env takes priority
+    message = @store.report(Logger::WARN, "test", "C", backtrace: "Garbage", env: { backtrace: error.backtrace })
+    assert_equal(error.backtrace.join("\n"), message.backtrace)
+
+    # Backtrace is always a string
+    # Cannot do an equal assert here, because it uses `caller` when not provided
+    message = @store.report(Logger::WARN, "test", "D", backtrace: nil)
+    assert_kind_of(String, message.backtrace)
+    message = @store.report(Logger::WARN, "test", "E", env: { backtrace: nil })
+    assert_kind_of(String, message.backtrace)
+    message = @store.report(Logger::WARN, "test", "F", backtrace: nil, env: { backtrace: nil })
+    assert_kind_of(String, message.backtrace)
+    message = @store.report(Logger::WARN, "test", "G")
+    assert_kind_of(String, message.backtrace)
+
+    # Arrays are turned into strings via join \n
+    message = @store.report(Logger::WARN, "test", "H", backtrace: ["Foo", "Bar"])
+    assert_equal("Foo\nBar", message.backtrace)
+  end
+end

data/test/logster/test_defer_logger.rb

@@ -1,34 +1,34 @@
-require_relative '../test_helper'
-require 'logster/defer_logger'
-require 'logster/logger'
-
-class TestDeferLogger < Minitest::Test
-  def setup
-    @store = TestStore.new
-    @defer_logger = Logster::DeferLogger.new(@store)
-  end
-
-  def test_defer_logger_inherits_logger
-    assert(Logster::Logger === @defer_logger)
-  end
-
-  def test_work_is_done_async
-    queue = Logster::Scheduler.queue
-    assert_equal(0, queue.size)
-
-    @defer_logger.add(4, "hi this a test", "prog")
-
-    assert_equal(1, queue.size)
-    queue << :terminate
-    Logster::Scheduler.thread.join
-    assert_equal(1, @store.calls.size)
-
-    # we need to make sure the backtrace is passed from the main thread.
-    # Otherwise we'd only get a partial backtrace from
-    # the point the new thread was spawned
-    backtrace = @store.calls.first[3][:backtrace]
-    assert_instance_of(Array, backtrace)
-
-    assert_equal(0, queue.size)
-  end
-end
+require_relative '../test_helper'
+require 'logster/defer_logger'
+require 'logster/logger'
+
+class TestDeferLogger < Minitest::Test
+  def setup
+    @store = TestStore.new
+    @defer_logger = Logster::DeferLogger.new(@store)
+  end
+
+  def test_defer_logger_inherits_logger
+    assert(Logster::Logger === @defer_logger)
+  end
+
+  def test_work_is_done_async
+    queue = Logster::Scheduler.queue
+    assert_equal(0, queue.size)
+
+    @defer_logger.add(4, "hi this a test", "prog")
+
+    assert_equal(1, queue.size)
+    queue << :terminate
+    Logster::Scheduler.thread.join
+    assert_equal(1, @store.calls.size)
+
+    # we need to make sure the backtrace is passed from the main thread.
+    # Otherwise we'd only get a partial backtrace from
+    # the point the new thread was spawned
+    backtrace = @store.calls.first[3][:backtrace]
+    assert_instance_of(Array, backtrace)
+
+    assert_equal(0, queue.size)
+  end
+end

data/test/logster/test_ignore_pattern.rb

@@ -1,41 +1,41 @@
-require_relative '../test_helper'
-require 'logster/ignore_pattern'
-
-class TestIgnorePattern < Minitest::Test
-
-  def test_string_message_pattern
-    msg = Logster::Message.new(Logger::WARN, "test", "my error")
-    msg_frog = Logster::Message.new(Logger::WARN, "test", "a frog")
-    msg_nil = Logster::Message.new(Logger::WARN, "test", nil)
-
-    pattern = Logster::IgnorePattern.new("ERROR")
-
-    assert pattern.matches? msg
-    assert !pattern.matches?(msg_frog)
-    assert !pattern.matches?(msg_nil)
-  end
-
-  def test_env_pattern
-    msg = Logster::Message.new(Logger::WARN, "test", "my error")
-    msg.env = { "frogs" => "are big" }
-
-    pattern = Logster::IgnorePattern.new(nil, frogs: "big")
-
-    assert pattern.matches? msg
-
-    msg.env = { legs: nil }
-    assert !(pattern.matches? msg)
-
-    msg.env = { legs: 3 }
-    assert !(pattern.matches? msg)
-
-    msg.env = { frogs: "small" }
-    assert !pattern.matches?(msg)
-
-    pattern = Logster::IgnorePattern.new(nil, "small")
-    assert pattern.matches? msg
-
-    msg.env = { frogs: "big" }
-    assert !(pattern.matches? msg)
-  end
-end
+require_relative '../test_helper'
+require 'logster/ignore_pattern'
+
+class TestIgnorePattern < Minitest::Test
+
+  def test_string_message_pattern
+    msg = Logster::Message.new(Logger::WARN, "test", "my error")
+    msg_frog = Logster::Message.new(Logger::WARN, "test", "a frog")
+    msg_nil = Logster::Message.new(Logger::WARN, "test", nil)
+
+    pattern = Logster::IgnorePattern.new("ERROR")
+
+    assert pattern.matches? msg
+    assert !pattern.matches?(msg_frog)
+    assert !pattern.matches?(msg_nil)
+  end
+
+  def test_env_pattern
+    msg = Logster::Message.new(Logger::WARN, "test", "my error")
+    msg.env = { "frogs" => "are big" }
+
+    pattern = Logster::IgnorePattern.new(nil, frogs: "big")
+
+    assert pattern.matches? msg
+
+    msg.env = { legs: nil }
+    assert !(pattern.matches? msg)
+
+    msg.env = { legs: 3 }
+    assert !(pattern.matches? msg)
+
+    msg.env = { frogs: "small" }
+    assert !pattern.matches?(msg)
+
+    pattern = Logster::IgnorePattern.new(nil, "small")
+    assert pattern.matches? msg
+
+    msg.env = { frogs: "big" }
+    assert !(pattern.matches? msg)
+  end
+end

data/test/logster/test_logger.rb

@@ -1,86 +1,86 @@
-require_relative '../test_helper'
-require 'logster/logger'
-require 'logger'
-
-class TestStore
-  attr_accessor :calls
-
-  def report(*args)
-    (@calls ||= []) << args
-  end
-end
-
-class TestLogger < Minitest::Test
-
-  def setup
-    @store = TestStore.new
-    @logger = Logster::Logger.new(@store)
-  end
-
-  def test_only_logs_valid_encoding
-    @logger.add(4, "a \xE4 test", "prog")
-    _, _, message = @store.calls[0]
-    assert_equal true, message.valid_encoding?
-  end
-
-  def test_per_thread_override
-    @logger.override_level = 2
-
-    @logger.add(0, "test", "prog", backtrace: "backtrace", env: { a: "x" })
-    Thread.new do
-      @logger.add(0, "test", "prog", backtrace: "backtrace", env: { a: "x" })
-    end.join
-
-    @logger.override_level = nil
-    @logger.add(0, "test", "prog", backtrace: "backtrace", env: { a: "x" })
-
-    assert_equal 2, @store.calls.length
-  end
-
-  def test_backtrace
-    @logger.add(0, "test", "prog", backtrace: "backtrace", env: { a: "x" })
-    assert_equal "backtrace", @store.calls[0][3][:backtrace]
-  end
-
-  def test_chain
-    io = StringIO.new
-    @logger.chain Logger.new(io)
-    @logger.warn "boom"
-
-    assert_match(/W,.*boom/, io.string)
-  end
-
-  def test_backtrace_with_chain
-    @other_store = TestStore.new
-    @logger.chain(Logster::Logger.new(@other_store))
-
-    @logger.add(0, "test", "prog", backtrace: "backtrace", env: { a: "x" })
-
-    [@store, @other_store].each do |store|
-      assert_equal "backtrace", store.calls[0][3][:backtrace]
-    end
-  end
-
-  def test_progname_parameter
-    @logger.add(0, "test")
-    progname = @store.calls[0][1]
-    assert_nil progname
-  end
-
-  class PlayLogger
-    attr_accessor :skip_store
-    def initialize(tester)
-      @tester = tester
-    end
-
-    def add(s, m, p, &block)
-      @tester.assert(skip_store)
-    end
-  end
-
-  def test_chain_with_ignore
-    @logger.chain PlayLogger.new(self)
-    @logger.skip_store = true
-    @logger.warn("testing")
-  end
-end
+require_relative '../test_helper'
+require 'logster/logger'
+require 'logger'
+
+class TestStore
+  attr_accessor :calls
+
+  def report(*args)
+    (@calls ||= []) << args
+  end
+end
+
+class TestLogger < Minitest::Test
+
+  def setup
+    @store = TestStore.new
+    @logger = Logster::Logger.new(@store)
+  end
+
+  def test_only_logs_valid_encoding
+    @logger.add(4, "a \xE4 test", "prog")
+    _, _, message = @store.calls[0]
+    assert_equal true, message.valid_encoding?
+  end
+
+  def test_per_thread_override
+    @logger.override_level = 2
+
+    @logger.add(0, "test", "prog", backtrace: "backtrace", env: { a: "x" })
+    Thread.new do
+      @logger.add(0, "test", "prog", backtrace: "backtrace", env: { a: "x" })
+    end.join
+
+    @logger.override_level = nil
+    @logger.add(0, "test", "prog", backtrace: "backtrace", env: { a: "x" })
+
+    assert_equal 2, @store.calls.length
+  end
+
+  def test_backtrace
+    @logger.add(0, "test", "prog", backtrace: "backtrace", env: { a: "x" })
+    assert_equal "backtrace", @store.calls[0][3][:backtrace]
+  end
+
+  def test_chain
+    io = StringIO.new
+    @logger.chain Logger.new(io)
+    @logger.warn "boom"
+
+    assert_match(/W,.*boom/, io.string)
+  end
+
+  def test_backtrace_with_chain
+    @other_store = TestStore.new
+    @logger.chain(Logster::Logger.new(@other_store))
+
+    @logger.add(0, "test", "prog", backtrace: "backtrace", env: { a: "x" })
+
+    [@store, @other_store].each do |store|
+      assert_equal "backtrace", store.calls[0][3][:backtrace]
+    end
+  end
+
+  def test_progname_parameter
+    @logger.add(0, "test")
+    progname = @store.calls[0][1]
+    assert_nil progname
+  end
+
+  class PlayLogger
+    attr_accessor :skip_store
+    def initialize(tester)
+      @tester = tester
+    end
+
+    def add(s, m, p, &block)
+      @tester.assert(skip_store)
+    end
+  end
+
+  def test_chain_with_ignore
+    @logger.chain PlayLogger.new(self)
+    @logger.skip_store = true
+    @logger.warn("testing")
+  end
+end