logster 2.12.1 → 2.13.0

data/test/logster/test_group.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative '../test_helper'
-require 'logster/group'
-require 'logster/message'
+require_relative "../test_helper"
+require "logster/group"
+require "logster/message"
 
 class TestGroup < MiniTest::Test
   def test_changed_is_true_for_new_instances
@@ -11,12 +11,13 @@ class TestGroup < MiniTest::Test
 
   def test_from_json_works_correctly
     time = (Time.now.to_f * 1000).to_i - 5000
-    json = JSON.generate(
-      key: '/somekey/',
-      messages_keys: [111, 222, 333].map(&:to_s),
-      timestamp: time,
-      count: 3
-    )
+    json =
+      JSON.generate(
+        key: "/somekey/",
+        messages_keys: [111, 222, 333].map(&:to_s),
+        timestamp: time,
+        count: 3,
+      )
     group = Logster::Group.from_json(json)
     refute group.changed?
     assert_equal 3, group.count
@@ -34,7 +35,7 @@ class TestGroup < MiniTest::Test
     assert_equal 1, group.count
 
     msg2 = get_message
-    msg2.timestamp -= 10000
+    msg2.timestamp -= 10_000
     group.add_message(msg2)
     assert_equal 2, group.count
     assert_equal msg1.timestamp, group.timestamp
@@ -42,12 +43,7 @@ class TestGroup < MiniTest::Test
 
   def test_adding_multiple_messages_works_correctly
     group = get_group
-    messages = [
-      get_message(10),
-      get_message(5),
-      get_message(74),
-      get_message(26)
-    ]
+    messages = [get_message(10), get_message(5), get_message(74), get_message(26)]
     messages << messages[0]
     group.messages = messages
     group.count = 4
@@ -66,7 +62,7 @@ class TestGroup < MiniTest::Test
       get_message(74),
       get_message(26),
       get_message(44),
-      get_message(390)
+      get_message(390),
     ]
     messages.each { |m| group.add_message(m) }
     # the count attr keeps track of the number of messages
@@ -91,6 +87,6 @@ class TestGroup < MiniTest::Test
   end
 
   def get_message(timestamp = nil)
-    Logster::Message.new(0, '', 'testmessage', timestamp)
+    Logster::Message.new(0, "", "testmessage", timestamp)
   end
 end

data/test/logster/test_ignore_pattern.rb

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
 
-require_relative '../test_helper'
-require 'logster/ignore_pattern'
+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 (oh no!)")
     msg_frog = Logster::Message.new(Logger::WARN, "test", "a frog")

data/test/logster/test_logger.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative '../test_helper'
-require 'logster/logger'
-require 'logger'
+require_relative "../test_helper"
+require "logster/logger"
+require "logger"
 
 class TestStore < Logster::BaseStore
   attr_accessor :calls
@@ -13,7 +13,6 @@ class TestStore < Logster::BaseStore
 end
 
 class TestLogger < Minitest::Test
-
   def setup
     @store = TestStore.new
     @logger = Logster::Logger.new(@store)
@@ -35,9 +34,7 @@ class TestLogger < Minitest::Test
     @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
+    Thread.new { @logger.add(0, "test", "prog", backtrace: "backtrace", env: { a: "x" }) }.join
 
     @logger.override_level = nil
     @logger.add(0, "test", "prog", backtrace: "backtrace", env: { a: "x" })
@@ -64,9 +61,7 @@ class TestLogger < Minitest::Test
 
     @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
+    [@store, @other_store].each { |store| assert_equal "backtrace", store.calls[0][3][:backtrace] }
   end
 
   def test_add_with_one_argument
@@ -76,7 +71,8 @@ class TestLogger < Minitest::Test
     assert_equal "test", @store.calls.first[2]
   end
 
-  class NewLogger < Logster::Logger; end
+  class NewLogger < Logster::Logger
+  end
 
   def test_inherited_logger_backtrace_with_chain
     @other_store = TestStore.new
@@ -85,9 +81,7 @@ class TestLogger < Minitest::Test
 
     @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
+    [@store, @other_store].each { |store| assert_equal "backtrace", store.calls[0][3][:backtrace] }
   end
 
   def test_progname_parameter
@@ -127,6 +121,12 @@ class TestLogger < Minitest::Test
     assert_equal custom_err.backtrace.join("\n"), @store.calls[2][3][:backtrace]
   end
 
+  def test_formatter
+    @logger.formatter = ->(severity, datetime, progname, msg) { "[test] #{msg}" }
+    @logger.add(0, "hello")
+    assert_equal "[test] hello", @store.calls[0][2]
+  end
+
   private
 
   def error_instance(error_class)

data/test/logster/test_message.rb

@@ -1,15 +1,14 @@
 # frozen_string_literal: true
 
-require_relative '../test_helper'
-require 'logster/message'
+require_relative "../test_helper"
+require "logster/message"
 
 class TestMessage < MiniTest::Test
-
   def test_merge_similar
-    msg1 = Logster::Message.new(0, '', 'test', 10)
+    msg1 = Logster::Message.new(0, "", "test", 10)
     msg1.populate_from_env(a: "1", b: "2")
 
-    msg2 = Logster::Message.new(0, '', 'test', 20)
+    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)
@@ -21,35 +20,35 @@ class TestMessage < MiniTest::Test
 
   def test_populate_from_env_will_add_time_to_env_unless_it_already_exists
     t = (Time.now.to_f * 1000).to_i
-    msg = Logster::Message.new(0, '', 'test', t)
+    msg = Logster::Message.new(0, "", "test", t)
     msg.populate_from_env({})
     assert_equal(t, msg.env["time"])
 
-    msg = Logster::Message.new(0, '', 'test', t)
+    msg = Logster::Message.new(0, "", "test", t)
     msg.populate_from_env(time: 5)
     assert_nil(msg.env["time"])
     assert_equal(5, msg.env[:time])
 
-    msg = Logster::Message.new(0, '', 'test', t)
+    msg = Logster::Message.new(0, "", "test", t)
     msg.populate_from_env("time" => 6)
     assert_equal(6, msg.env["time"])
     assert_nil(msg.env[:time])
 
-    msg = Logster::Message.new(0, '', 'test', t)
+    msg = Logster::Message.new(0, "", "test", t)
     msg.populate_from_env([{ "time" => 6 }, { "time" => 8 }])
     assert_equal([6, 8], msg.env.map { |e| e["time"] })
     assert_equal([nil, nil], msg.env.map { |e| e[:time] })
 
-    msg = Logster::Message.new(0, '', 'test', t)
+    msg = Logster::Message.new(0, "", "test", t)
     msg.populate_from_env([{ dsd: 6 }, { dsd: 8 }])
     assert_equal([t, t], msg.env.map { |e| e["time"] })
   end
 
   def test_merge_messages_both_with_array_envs
-    msg1 = Logster::Message.new(0, '', 'test', 10)
+    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 = Logster::Message.new(0, "", "test", 20)
     msg2.env = [{ e: "ee", f: "ff" }, { g: "gg", h: "hh" }]
 
     msg1.merge_similar_message(msg2)
@@ -57,10 +56,10 @@ class TestMessage < MiniTest::Test
   end
 
   def test_merge_messages_one_with_array_envs
-    msg1 = Logster::Message.new(0, '', 'test', 10)
+    msg1 = Logster::Message.new(0, "", "test", 10)
     msg1.env = { e: "ee", f: "ff" }
 
-    msg2 = Logster::Message.new(0, '', 'test', 20)
+    msg2 = Logster::Message.new(0, "", "test", 20)
     msg2.env = [{ a: "aa", b: "bb" }, { c: "cc", d: "dd" }]
 
     msg1.merge_similar_message(msg2)
@@ -69,11 +68,10 @@ class TestMessage < MiniTest::Test
 
   def test_adds_application_version
     Logster.config.application_version = "abc"
-    msg = Logster::Message.new(0, '', 'test', 10)
+    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
@@ -81,7 +79,7 @@ class TestMessage < MiniTest::Test
   def test_use_full_hostname
     Logster::Message.instance_variable_set(:@hostname, nil)
     Logster.config.use_full_hostname = true
-    msg = Logster::Message.new(0, '', 'test', 10)
+    msg = Logster::Message.new(0, "", "test", 10)
     msg.populate_from_env({})
 
     assert_equal(`hostname -f`.strip!, msg.env["hostname"])
@@ -91,8 +89,8 @@ class TestMessage < MiniTest::Test
   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)
+    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)
@@ -108,8 +106,8 @@ class TestMessage < MiniTest::Test
       message: "invalid encoding",
       env: {
         a: "bad_value",
-        b: ["bad_value"]
-      }
+        b: ["bad_value"],
+      },
     }
     json = hash.to_json.gsub("bad_value", "45\xC0\xBE")
     message = Logster::Message.from_json(json)
@@ -120,7 +118,7 @@ class TestMessage < MiniTest::Test
   end
 
   def test_populate_from_env_works_on_array
-    msg = Logster::Message.new(0, '', 'test', 10)
+    msg = Logster::Message.new(0, "", "test", 10)
     hash = { "custom_key" => "key" }
     msg.populate_from_env([hash])
 
@@ -130,9 +128,9 @@ class TestMessage < MiniTest::Test
   end
 
   def test_merging_envs_add_new_envs_to_buffer
-    msg1 = Logster::Message.new(0, '', 'test', 10, count: 50)
+    msg1 = Logster::Message.new(0, "", "test", 10, count: 50)
     msg1.env = 50.times.map { |n| { a: n } }
-    msg2 = Logster::Message.new(0, '', 'test', 20, count: 13)
+    msg2 = Logster::Message.new(0, "", "test", 20, count: 13)
     msg2.env = 13.times.map { |n| { b: n } }
 
     assert_equal(msg1.grouping_key, msg2.grouping_key)
@@ -159,7 +157,7 @@ class TestMessage < MiniTest::Test
   end
 
   def test_drop_redundant_envs
-    message = Logster::Message.new(Logger::WARN, '', 'message')
+    message = Logster::Message.new(Logger::WARN, "", "message")
     message.env = [{ a: 4 }] * 10
     assert_equal(10, message.env.size)
     message.drop_redundant_envs(5)
@@ -172,7 +170,7 @@ class TestMessage < MiniTest::Test
   end
 
   def test_apply_env_size_limit_keeps_as_many_keys_as_possible
-    message = Logster::Message.new(Logger::WARN, '', 'message', 1)
+    message = Logster::Message.new(Logger::WARN, "", "message", 1)
     env = { a: 1, bb: 22, ccc: 333 }
     message.env = env.dup
     message.apply_env_size_limit(24)
@@ -207,7 +205,7 @@ class TestMessage < MiniTest::Test
       /var/www/discourse/lib/scheduler/defer.rb:79:in `block (2 levels) in start_thread'
     TEXT
     gems_dir = "/var/www/discourse/vendor/bundle/ruby/2.6.0/gems/"
-    message = Logster::Message.new(Logger::WARN, '', 'message', 1)
+    message = Logster::Message.new(Logger::WARN, "", "message", 1)
 
     message.backtrace = backtrace.dup
     assert_operator(message.to_json(exclude_env: true).bytesize, :>=, 500)
@@ -229,7 +227,7 @@ class TestMessage < MiniTest::Test
       rails_multisite-2.0.7/lib/rails_multisite/connection_management.rb:60:in `with_connection'
       /var/www/discourse
     TEXT
-    message = Logster::Message.new(Logger::WARN, '', 'message', 1)
+    message = Logster::Message.new(Logger::WARN, "", "message", 1)
     message.backtrace = backtrace.dup
     assert_operator(message.to_json(exclude_env: true).bytesize, :>=, 350)
     message.apply_message_size_limit(350)
@@ -239,7 +237,7 @@ class TestMessage < MiniTest::Test
 
   def test_truncate_backtrace_shouldnt_corrupt_backtrace_when_it_contains_multibytes_characters
     backtrace = "aहa"
-    message = Logster::Message.new(Logger::WARN, '', 'message', 1)
+    message = Logster::Message.new(Logger::WARN, "", "message", 1)
     message.backtrace = backtrace.dup
     message.truncate_backtrace(3)
     assert_equal("a", message.backtrace)
@@ -254,7 +252,7 @@ class TestMessage < MiniTest::Test
   end
 
   def test_apply_message_size_limit_doesnt_remove_backtrace_entirely
-    message = Logster::Message.new(Logger::WARN, '', 'message', 1)
+    message = Logster::Message.new(Logger::WARN, "", "message", 1)
     message.backtrace = "a" * 1000
     assert_operator(message.to_json(exclude_env: true).bytesize, :>=, 500)
     message.apply_message_size_limit(500)
@@ -263,7 +261,7 @@ class TestMessage < MiniTest::Test
   end
 
   def test_apply_message_size_limit_doesnt_hang_forever_and_doesnt_remove_backtrace_entirely
-    message = Logster::Message.new(Logger::WARN, '', 'message', 1)
+    message = Logster::Message.new(Logger::WARN, "", "message", 1)
     message.backtrace = "aa" * 100
     message.apply_message_size_limit(10)
     assert_equal(("aa" * 100).size, message.backtrace.size)

data/test/logster/test_pattern.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative '../test_helper'
-require 'logster/redis_store'
-require 'logster/pattern'
+require_relative "../test_helper"
+require "logster/redis_store"
+require "logster/pattern"
 
 class TestPattern < Minitest::Test
   class FakePattern < Logster::Pattern
@@ -90,22 +90,16 @@ class TestPattern < Minitest::Test
   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
+      assert_raises(Logster::Pattern::PatternError) { FakePattern.new(p).save }
     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
+    good_patterns.each { |p| FakePattern.new(p).save }
     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
+    results.each { |p| assert_includes(good_patterns_regex, p) }
   end
 
   def test_modify_works_correctly
@@ -123,9 +117,7 @@ class TestPattern < Minitest::Test
     record = FakePattern.new(/LoGsTEr/)
     record.save
 
-    assert_raises(Logster::Pattern::PatternError) do
-      record.modify("/badReg")
-    end
+    assert_raises(Logster::Pattern::PatternError) { record.modify("/badReg") }
     all_patterns = FakePattern.find_all
     assert_equal(1, all_patterns.size)
     assert_equal(/LoGsTEr/, all_patterns.first)

data/test/logster/test_redis_rate_limiter.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative '../test_helper'
-require 'logster/redis_store'
-require 'rack'
+require_relative "../test_helper"
+require "logster/redis_store"
+require "rack"
 
 class TestRedisRateLimiter < Minitest::Test
   def setup
@@ -19,13 +19,17 @@ class TestRedisRateLimiter < Minitest::Test
 
     @redis.set("dont_nuke", "1")
 
-    @rate_limiter = Logster::RedisRateLimiter.new(
-      @redis, [Logger::WARN], 8, 60, Proc.new { "prefix" }, Proc.new { called += 1 }
-    )
+    @rate_limiter =
+      Logster::RedisRateLimiter.new(
+        @redis,
+        [Logger::WARN],
+        8,
+        60,
+        Proc.new { "prefix" },
+        Proc.new { called += 1 },
+      )
 
-    9.times do
-      @rate_limiter.check(Logger::WARN)
-    end
+    9.times { @rate_limiter.check(Logger::WARN) }
 
     assert_equal 10, @rate_limiter.check(Logger::WARN)
 
@@ -40,7 +44,6 @@ class TestRedisRateLimiter < Minitest::Test
 
     assert_equal "1", @redis.get("dont_nuke")
     @redis.del("dont_nuke")
-
   end
 
   def test_check
@@ -48,9 +51,8 @@ class TestRedisRateLimiter < Minitest::Test
     Timecop.freeze(time)
     called = 0
 
-    @rate_limiter = Logster::RedisRateLimiter.new(
-      @redis, [Logger::WARN], 8, 60, nil, Proc.new { called += 1 }
-    )
+    @rate_limiter =
+      Logster::RedisRateLimiter.new(@redis, [Logger::WARN], 8, 60, nil, Proc.new { called += 1 })
 
     assert_equal(1, @rate_limiter.check(Logger::WARN))
     assert_redis_key(60, 0)
@@ -113,9 +115,15 @@ class TestRedisRateLimiter < Minitest::Test
     Timecop.freeze(time)
     called = 0
 
-    @rate_limiter = Logster::RedisRateLimiter.new(
-      @redis, [Logger::WARN, Logger::ERROR], 4, 60, nil, Proc.new { called += 1 }
-    )
+    @rate_limiter =
+      Logster::RedisRateLimiter.new(
+        @redis,
+        [Logger::WARN, Logger::ERROR],
+        4,
+        60,
+        nil,
+        Proc.new { called += 1 },
+      )
 
     assert_equal(1, @rate_limiter.check(Logger::WARN))
     assert_equal(2, @rate_limiter.check(Logger::ERROR))
@@ -170,16 +178,22 @@ class TestRedisRateLimiter < Minitest::Test
   def test_raw_connection
     time = Time.new(2015, 1, 1, 1, 1)
     Timecop.freeze(time)
-    @rate_limiter = Logster::RedisRateLimiter.new(@redis, [Logger::WARN], 1, 60, Proc.new { "lobster" })
+    @rate_limiter =
+      Logster::RedisRateLimiter.new(@redis, [Logger::WARN], 1, 60, Proc.new { "lobster" })
 
     assert_equal(1, @rate_limiter.check(Logger::WARN))
     assert_redis_key(60, 0)
 
     toggle = true
 
-    @rate_limiter = Logster::RedisRateLimiter.new(
-      @redis, [Logger::WARN], 1, 60, Proc.new { toggle ? 'lobster1' : 'lobster2' }
-    )
+    @rate_limiter =
+      Logster::RedisRateLimiter.new(
+        @redis,
+        [Logger::WARN],
+        1,
+        60,
+        Proc.new { toggle ? "lobster1" : "lobster2" },
+      )
 
     assert_includes(key, "lobster1")
 
@@ -188,7 +202,7 @@ class TestRedisRateLimiter < Minitest::Test
   end
 
   def test_retrieve_rate
-    time = Time.new(2015, 1, 1, 1 , 1)
+    time = Time.new(2015, 1, 1, 1, 1)
     Timecop.freeze(time)
 
     @rate_limiter = Logster::RedisRateLimiter.new(@redis, [Logger::WARN], 1, 60)