logster 2.1.2 → 2.2.0

data/test/logster/test_logger.rb

@@ -1,86 +1,100 @@
-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
+
+  class NewLogger < Logster::Logger; end
+
+  def test_inherited_logger_backtrace_with_chain
+    @other_store = TestStore.new
+    @logger = NewLogger.new(@store)
+    @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

data/test/logster/test_message.rb

@@ -1,119 +1,119 @@
-require_relative '../test_helper'
-require 'logster/message'
-
-class TestMessage < MiniTest::Test
-
-  def test_merge_similar
-    msg1 = Logster::Message.new(0, '', 'test', 10)
-    msg1.populate_from_env(a: "1", b: "2")
-
-    msg2 = Logster::Message.new(0, '', 'test', 20)
-    msg2.populate_from_env(a: "2", c: "3")
-
-    assert_equal(msg2.grouping_key, msg1.grouping_key)
-
-    msg1.merge_similar_message(msg2)
-
-    assert_equal(20, msg1.timestamp)
-    assert_equal(10, msg1.first_timestamp)
-
-    assert Array === msg1.env
-    assert_equal(msg1.env.size, 2)
-    assert({ a: "1", b: "2" } <= msg1.env[0])
-    assert({ "a" => "2", "c" => "3" } <= msg1.env[1])
-  end
-
-  def test_merge_messages_both_with_array_envs
-    msg1 = Logster::Message.new(0, '', 'test', 10)
-    msg1.env = [{ a: "aa", b: "bb" }, { c: "cc", d: "dd" }]
-
-    msg2 = Logster::Message.new(0, '', 'test', 20)
-    msg2.env = [{ e: "ee", f: "ff" }, { g: "gg", h: "hh" }]
-
-    msg1.merge_similar_message(msg2)
-
-    # new env should be an array, but it should never have
-    # another array of envs within itself (hence flatten(1))
-    assert_equal(msg1.env.size, 4)
-    assert_equal(msg1.env.map(&:keys).flatten(1).map(&:to_s), %w{a b c d e f g h})
-    assert_equal(msg1.env.map(&:values).flatten(1).map(&:to_s), %w{aa bb cc dd ee ff gg hh})
-  end
-
-  def test_merge_messages_one_with_array_envs
-    msg1 = Logster::Message.new(0, '', 'test', 10)
-    msg1.env = [{ a: "aa", b: "bb" }, { c: "cc", d: "dd" }]
-
-    msg2 = Logster::Message.new(0, '', 'test', 20)
-    msg2.env = { e: "ee", f: "ff" }
-
-    msg1.merge_similar_message(msg2)
-
-    assert_equal(msg1.env.size, 3)
-    assert_equal(msg1.env.map(&:keys).flatten(1).map(&:to_s), %w{a b c d e f})
-    assert_equal(msg1.env.map(&:values).flatten(1).map(&:to_s), %w{aa bb cc dd ee ff})
-  end
-
-  def test_adds_application_version
-    Logster.config.application_version = "abc"
-    msg = Logster::Message.new(0, '', 'test', 10)
-    msg.populate_from_env({})
-
-    assert_equal("abc", msg.env["application_version"])
-
-  ensure
-    Logster.config.application_version = nil
-  end
-
-  def test_merging_sums_count_for_both_messages
-    msg1 = Logster::Message.new(0, '', 'test', 10, count: 15)
-    msg2 = Logster::Message.new(0, '', 'test', 20, count: 13)
-    msg2.env = {}
-
-    assert_equal(msg1.grouping_key, msg2.grouping_key)
-
-    save_env = msg1.merge_similar_message(msg2)
-    assert(save_env)
-    assert_equal(msg1.count, 15 + 13)
-  end
-
-  def test_populate_from_env_works_on_array
-    msg = Logster::Message.new(0, '', 'test', 10)
-    hash = { "custom_key" => "key" }
-    msg.populate_from_env([hash])
-
-    assert Array === msg.env
-    assert_equal(msg.env.size, 1)
-    assert hash <= msg.env[0]
-  end
-
-  def test_ensure_env_samples_dont_exceed_50
-    msg1 = Logster::Message.new(0, '', 'test', 10, count: 50)
-    msg1.env = [{ a: 1 }]
-    msg2 = Logster::Message.new(0, '', 'test', 20, count: 13)
-    msg2.env = { b: 2 }
-
-    assert_equal(msg1.grouping_key, msg2.grouping_key)
-
-    save_env = msg1.merge_similar_message(msg2)
-
-    refute(save_env)
-    assert_equal(63, msg1.count) # update count
-    assert_equal([{ a: 1 }], msg1.env) # but don't merge msg2's env into msg1's
-  end
-
-  def test_message_to_h_respects_params
-    msg = Logster::Message.new(0, "", "test")
-    test_hash = { test_key: "this is a test" }
-    msg.env = test_hash
-    assert_equal(test_hash, msg.to_h[:env])
-    assert_nil(msg.to_h(exclude_env: true)[:env])
-  end
-
-  def test_message_to_json_respects_params
-    msg = Logster::Message.new(0, "", "test")
-    test_hash = { test_key: "this is a test" }
-    msg.env = test_hash
-    assert_includes(msg.to_json, test_hash.to_json)
-    refute_includes(msg.to_json(exclude_env: true), test_hash.to_json)
-  end
-end
+require_relative '../test_helper'
+require 'logster/message'
+
+class TestMessage < MiniTest::Test
+
+  def test_merge_similar
+    msg1 = Logster::Message.new(0, '', 'test', 10)
+    msg1.populate_from_env(a: "1", b: "2")
+
+    msg2 = Logster::Message.new(0, '', 'test', 20)
+    msg2.populate_from_env(a: "2", c: "3")
+
+    assert_equal(msg2.grouping_key, msg1.grouping_key)
+
+    msg1.merge_similar_message(msg2)
+
+    assert_equal(20, msg1.timestamp)
+    assert_equal(10, msg1.first_timestamp)
+
+    assert Array === msg1.env
+    assert_equal(msg1.env.size, 2)
+    assert({ a: "1", b: "2" } <= msg1.env[0])
+    assert({ "a" => "2", "c" => "3" } <= msg1.env[1])
+  end
+
+  def test_merge_messages_both_with_array_envs
+    msg1 = Logster::Message.new(0, '', 'test', 10)
+    msg1.env = [{ a: "aa", b: "bb" }, { c: "cc", d: "dd" }]
+
+    msg2 = Logster::Message.new(0, '', 'test', 20)
+    msg2.env = [{ e: "ee", f: "ff" }, { g: "gg", h: "hh" }]
+
+    msg1.merge_similar_message(msg2)
+
+    # new env should be an array, but it should never have
+    # another array of envs within itself (hence flatten(1))
+    assert_equal(msg1.env.size, 4)
+    assert_equal(msg1.env.map(&:keys).flatten(1).map(&:to_s), %w{a b c d e f g h})
+    assert_equal(msg1.env.map(&:values).flatten(1).map(&:to_s), %w{aa bb cc dd ee ff gg hh})
+  end
+
+  def test_merge_messages_one_with_array_envs
+    msg1 = Logster::Message.new(0, '', 'test', 10)
+    msg1.env = [{ a: "aa", b: "bb" }, { c: "cc", d: "dd" }]
+
+    msg2 = Logster::Message.new(0, '', 'test', 20)
+    msg2.env = { e: "ee", f: "ff" }
+
+    msg1.merge_similar_message(msg2)
+
+    assert_equal(msg1.env.size, 3)
+    assert_equal(msg1.env.map(&:keys).flatten(1).map(&:to_s), %w{a b c d e f})
+    assert_equal(msg1.env.map(&:values).flatten(1).map(&:to_s), %w{aa bb cc dd ee ff})
+  end
+
+  def test_adds_application_version
+    Logster.config.application_version = "abc"
+    msg = Logster::Message.new(0, '', 'test', 10)
+    msg.populate_from_env({})
+
+    assert_equal("abc", msg.env["application_version"])
+
+  ensure
+    Logster.config.application_version = nil
+  end
+
+  def test_merging_sums_count_for_both_messages
+    msg1 = Logster::Message.new(0, '', 'test', 10, count: 15)
+    msg2 = Logster::Message.new(0, '', 'test', 20, count: 13)
+    msg2.env = {}
+
+    assert_equal(msg1.grouping_key, msg2.grouping_key)
+
+    save_env = msg1.merge_similar_message(msg2)
+    assert(save_env)
+    assert_equal(msg1.count, 15 + 13)
+  end
+
+  def test_populate_from_env_works_on_array
+    msg = Logster::Message.new(0, '', 'test', 10)
+    hash = { "custom_key" => "key" }
+    msg.populate_from_env([hash])
+
+    assert Array === msg.env
+    assert_equal(msg.env.size, 1)
+    assert hash <= msg.env[0]
+  end
+
+  def test_ensure_env_samples_dont_exceed_50
+    msg1 = Logster::Message.new(0, '', 'test', 10, count: 50)
+    msg1.env = [{ a: 1 }]
+    msg2 = Logster::Message.new(0, '', 'test', 20, count: 13)
+    msg2.env = { b: 2 }
+
+    assert_equal(msg1.grouping_key, msg2.grouping_key)
+
+    save_env = msg1.merge_similar_message(msg2)
+
+    refute(save_env)
+    assert_equal(63, msg1.count) # update count
+    assert_equal([{ a: 1 }], msg1.env) # but don't merge msg2's env into msg1's
+  end
+
+  def test_message_to_h_respects_params
+    msg = Logster::Message.new(0, "", "test")
+    test_hash = { test_key: "this is a test" }
+    msg.env = test_hash
+    assert_equal(test_hash, msg.to_h[:env])
+    assert_nil(msg.to_h(exclude_env: true)[:env])
+  end
+
+  def test_message_to_json_respects_params
+    msg = Logster::Message.new(0, "", "test")
+    test_hash = { test_key: "this is a test" }
+    msg.env = test_hash
+    assert_includes(msg.to_json, test_hash.to_json)
+    refute_includes(msg.to_json(exclude_env: true), test_hash.to_json)
+  end
+end

data/test/logster/test_pattern.rb

@@ -0,0 +1,152 @@
+require_relative '../test_helper'
+require 'logster/redis_store'
+require 'logster/pattern'
+
+class TestPattern < Minitest::Test
+  class FakePattern < Logster::Pattern
+    def self.set_name
+      "__LOGSTER__fake_patterns_set".freeze
+    end
+  end
+
+  Logster::PATTERNS << FakePattern
+
+  class TestRedisStore < Logster::BaseStore
+    def get_patterns(set_name)
+      ["/differentstore/"]
+    end
+  end
+
+  def setup
+    Logster.store = Logster::RedisStore.new
+    Logster.store.clear_all
+  end
+
+  def teardown
+    Logster.store.clear_all
+    Logster.store = nil
+  end
+
+  def test_parse_pattern_works_correctly
+    assert_equal(/osama/i, klass.parse_pattern(/osama/i))
+    assert_equal(/osama/i, klass.parse_pattern("/osama/i"))
+    assert_equal(/osama/, klass.parse_pattern("/osama/"))
+    assert_equal(/osama/, klass.parse_pattern("osama"))
+    assert_equal(/[a-zA-Z]/, klass.parse_pattern("[a-zA-Z]"))
+    assert_equal(/[a-zA-Z]/, klass.parse_pattern("/[a-zA-Z]/"))
+
+    assert_nil(klass.parse_pattern("/osama"))
+    assert_nil(klass.parse_pattern("["))
+    assert_nil(klass.parse_pattern("/[/"))
+  end
+
+  def test_validity_checks_are_correct
+    assert(klass.valid?(/osama/))
+    refute(klass.valid?(//))
+    refute(klass.valid?(//i))
+    refute(klass.valid?(/ /))
+  end
+
+  def test_find_all_works_correctly
+    patterns = ["/test/i", "tttt", "[d-y].*"]
+    patterns.each { |p| FakePattern.new(p).save }
+
+    results = FakePattern.find_all
+    assert_equal(3, results.size)
+    assert_includes(results, /test/i)
+    assert_includes(results, /tttt/)
+    assert_includes(results, /[d-y].*/)
+
+    results = FakePattern.find_all(raw: true)
+    assert_equal(3, results.size)
+    assert_includes(results, "/test/i")
+    assert_includes(results, "/tttt/")
+    assert_includes(results, "/[d-y].*/")
+  end
+
+  def test_find_all_can_take_an_instance_of_store
+    results = FakePattern.find_all(store: TestRedisStore.new)
+    assert_equal(1, results.size)
+    assert_equal(/differentstore/, results.first)
+  end
+
+  def test_find_works_correctly
+    FakePattern.new("/wwwlll/").save
+
+    record = FakePattern.find("wwwlll")
+    assert_equal(/wwwlll/, record.pattern)
+    record = FakePattern.find(/wwwlll/)
+    assert_equal(/wwwlll/, record.pattern)
+
+    assert_nil(FakePattern.find("dfsdfsdf"))
+    assert_nil(FakePattern.find(nil))
+  end
+
+  def test_patterns_get_parsed_on_initialize
+    assert_equal(/mypattern/, FakePattern.new("mypattern").pattern)
+    assert_equal(/111333/, FakePattern.new(/111333/).pattern)
+  end
+
+  def test_save_works_correctly
+    bad_patterns = ["/bruken", nil, "[a-z", "/(osa|sss{1/"]
+    bad_patterns.each do |p|
+      assert_raises(Logster::Pattern::PatternError) do
+        FakePattern.new(p).save
+      end
+    end
+    assert_equal(0, FakePattern.find_all.size)
+
+    good_patterns = ["/logster/i", /logster/, "sssd", "(ccx|tqe){1,5}", "logster"]
+    good_patterns.each do |p|
+      FakePattern.new(p).save
+    end
+    results = FakePattern.find_all
+    assert_equal(4, results.size) # 4 because /logster/ and logster are the same
+    good_patterns_regex = [/logster/i, /logster/, /sssd/, /(ccx|tqe){1,5}/]
+    results.each do |p|
+      assert_includes(good_patterns_regex, p)
+    end
+  end
+
+  def test_modify_works_correctly
+    record = FakePattern.new(/logster/)
+    record.save
+
+    record.modify("/LoGsTEr/")
+    all_patterns = FakePattern.find_all
+    assert_equal(1, all_patterns.size)
+    assert_equal(/LoGsTEr/, all_patterns.first)
+    assert_equal(/LoGsTEr/, record.pattern)
+  end
+
+  def test_modify_doesnt_remove_old_pattern_when_new_is_bad
+    record = FakePattern.new(/LoGsTEr/)
+    record.save
+
+    assert_raises(Logster::Pattern::PatternError) do
+      record.modify("/badReg")
+    end
+    all_patterns = FakePattern.find_all
+    assert_equal(1, all_patterns.size)
+    assert_equal(/LoGsTEr/, all_patterns.first)
+    assert_equal(/LoGsTEr/, record.pattern)
+  end
+
+  def test_destroy_works_correctly
+    record = FakePattern.new(/somepattern/)
+    record.save
+
+    patterns = FakePattern.find_all
+    assert_equal(1, patterns.size)
+    assert_equal(/somepattern/, patterns.first)
+
+    record.destroy
+    assert_equal(0, FakePattern.find_all.size)
+  end
+
+  private
+
+  def klass
+    Logster::Pattern
+  end
+end