logster 2.20.1 → 3.0.0

data/test/logster/test_base_store.rb

@@ -1,224 +0,0 @@
-# frozen_string_literal: true
-
-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: %r{/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: %w[Foo Bar])
-    assert_equal("Foo\nBar", message.backtrace)
-  end
-
-  def test_chained_loggers_dont_have_superfluous_frames_in_backtrace
-    logger = Logster::Logger.new(@store)
-    other_store = Logster::TestStore.new
-    other_logger = Logster::Logger.new(other_store)
-    logger.chain(other_logger)
-    logger.warn("this is warning")
-    [@store, other_store].each do |store|
-      message = store.reported.first
-      assert_equal("this is warning", message.message)
-      # the first line in the backtrace should be the method that
-      # called the warn/info/error etc. method.
-      # in this case the first line should be this test method
-      assert_includes(message.backtrace.lines.first, __method__.to_s)
-    end
-  end
-
-  def test_log_message_is_truncated_when_above_maximum_message_length
-    orig = Logster.config.maximum_message_length
-    Logster.config.maximum_message_length = 300
-    msg = @store.report(Logger::WARN, "", "a" * 400)
-    # 3 is the ... at the end to indicate truncated message
-    assert_equal(300 + 3, msg.message.size)
-
-    Logster.config.maximum_message_length = 100
-    msg = @store.report(Logger::WARN, "", "a" * 200)
-    assert_equal(100 + 3, msg.message.size)
-  ensure
-    Logster.config.maximum_message_length = orig
-  end
-
-  def test_chained_loggers_shouldnt_mutate_env_passed_to_them
-    logger = Logster::Logger.new(@store)
-    other_store = Logster::TestStore.new
-    other_logger = Logster::Logger.new(other_store)
-    logger.chain(other_logger)
-    logger.add(Logger::WARN, "this is warning", "", { env: { backtrace: "11" } })
-    [@store, other_store].each do |store|
-      assert_equal("11", store.reported.first.backtrace)
-      refute_includes(store.reported.first.env.keys.map(&:to_sym), :backtrace)
-    end
-  end
-
-  def test_envs_with_invalid_encoding_dont_raise_errors
-    msg = @store.report(Logger::WARN, "", "me have invalid encoding", env: { axe: "a\xF1xasa" })
-    assert_equal("a�xasa", msg.env[:axe])
-  end
-end

data/test/logster/test_cache.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../test_helper"
-require "logster/cache"
-
-class TestCache < Minitest::Test
-  def setup
-    @cache = Logster::Cache.new(5)
-  end
-
-  def test_cache_works
-    prc = Proc.new { |key, value| @cache.fetch(key) { value } }
-    value = "I should be retured"
-    assert_equal(value, prc.call(:key1, value))
-    cached_value = value
-    value = "I shouldn't be returned"
-    assert_equal(cached_value, prc.call(:key1, value))
-    value2 = "value for key2"
-    assert_equal(value2, prc.call(:key2, value2))
-
-    value = value2 = "Now I should be returned"
-    Process.stub :clock_gettime, Process.clock_gettime(Process::CLOCK_MONOTONIC) + 6 do
-      assert_equal(value, prc.call(:key1, value))
-      assert_equal(value2, prc.call(:key2, value2))
-    end
-  end
-
-  def test_cache_can_be_cleared
-    value = "cached"
-    prc = Proc.new { |key, val| @cache.fetch(key) { val } }
-    assert_equal(value, prc.call(:key1, value))
-    assert_equal("v2", prc.call(:key2, "v2"))
-
-    value = "new value"
-    @cache.clear(:key1)
-    assert_equal(value, prc.call(:key1, value))
-    assert_equal("v2", prc.call(:key2, "v2.2"))
-  end
-end

data/test/logster/test_defer_logger.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-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_includes(backtrace.lines.first, __method__.to_s)
-
-    assert_equal(0, queue.size)
-  end
-end

data/test/logster/test_group.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../test_helper"
-require "logster/group"
-require "logster/message"
-
-class TestGroup < MiniTest::Test
-  def test_changed_is_true_for_new_instances
-    assert Logster::Group.new("/somekey/").changed?
-  end
-
-  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,
-      )
-    group = Logster::Group.from_json(json)
-    refute group.changed?
-    assert_equal 3, group.count
-    assert_equal time, group.timestamp
-  end
-
-  def test_doesnt_add_duplicate_messages
-    group = get_group
-    msg1 = get_message
-    assert_equal 0, group.count
-    group.add_message(msg1)
-    assert_equal 1, group.count
-    assert_equal msg1.timestamp, group.timestamp
-    group.add_message(msg1)
-    assert_equal 1, group.count
-
-    msg2 = get_message
-    msg2.timestamp -= 10_000
-    group.add_message(msg2)
-    assert_equal 2, group.count
-    assert_equal msg1.timestamp, group.timestamp
-  end
-
-  def test_adding_multiple_messages_works_correctly
-    group = get_group
-    messages = [get_message(10), get_message(5), get_message(74), get_message(26)]
-    messages << messages[0]
-    group.messages = messages
-    group.count = 4
-    assert_equal 4, group.count
-    assert_equal 74, group.timestamp
-    expected = messages.uniq(&:key).sort_by(&:timestamp).map(&:key).reverse
-    assert_equal expected, group.messages_keys
-  end
-
-  def test_doesnt_exceed_max_size
-    Logster::Group.instance_variable_set(:@max_size, 5)
-    group = get_group
-    messages = [
-      get_message(10),
-      get_message(5),
-      get_message(74),
-      get_message(26),
-      get_message(44),
-      get_message(390),
-    ]
-    messages.each { |m| group.add_message(m) }
-    # the count attr keeps track of the number of messages
-    # that has ever been added to the group.
-    # It should never decrease
-    assert_equal 6, group.count
-    assert_equal 390, group.timestamp
-    refute_includes group.messages_keys, messages.find { |m| m.timestamp == 10 }.key
-
-    group = get_group
-    group.messages = messages
-    assert_equal 390, group.timestamp
-    refute_includes group.messages.map(&:timestamp), 5
-  ensure
-    Logster::Group.remove_instance_variable(:@max_size)
-  end
-
-  private
-
-  def get_group
-    Logster::Group.new("/groupkey/")
-  end
-
-  def get_message(timestamp = nil)
-    Logster::Message.new(0, "", "testmessage", timestamp)
-  end
-end

data/test/logster/test_ignore_pattern.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-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")
-    msg_nil = Logster::Message.new(Logger::WARN, "test", nil)
-
-    pattern = Logster::IgnorePattern.new("my 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,177 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../test_helper"
-require "logster/logger"
-require "logger"
-
-class TestStore < Logster::BaseStore
-  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
-    logger2 = Logster::Logger.new(@store)
-    logger2.override_level = 2
-
-    # we should not leak between objects
-    assert_nil @logger.override_level
-
-    @logger.override_level = 2
-
-    @logger.add(0, "test", "prog", backtrace: "backtrace", env: { a: "x" })
-    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" })
-
-    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 { |store| assert_equal "backtrace", store.calls[0][3][:backtrace] }
-  end
-
-  def test_add_with_one_argument
-    @logger.add(2) { "test" }
-    @logger.add(2)
-    assert_equal 2, @store.calls.length
-    assert_equal "test", @store.calls.first[2]
-  end
-
-  def test_subscribing_to_logger_events
-    custom_logger_klass =
-      Class.new do
-        attr_reader :events
-
-        def initialize
-          @events = []
-        end
-
-        def log(severity, message, progname, opts, &block)
-          @events.push({ severity:, message:, progname:, opts:, block: })
-        end
-      end
-
-    custom_logger = custom_logger_klass.new
-
-    @logger.subscribe do |severity, message, progname, opts, &block|
-      custom_logger.log(severity, message, progname, opts, &block)
-    end
-
-    @logger.add(0, "test", "prog", backtrace: "backtrace", env: { a: "x" })
-    @logger.add(1, nil, nil, backtrace: "backtrace") { "yielded message" }
-
-    first_event = custom_logger.events[0]
-
-    assert_equal(0, first_event[:severity])
-    assert_equal("test", first_event[:message])
-    assert_equal("prog", first_event[:progname])
-    assert_equal({ backtrace: "backtrace", env: { a: "x" } }, first_event[:opts])
-    assert_nil first_event[:block]
-
-    second_event = custom_logger.events[1]
-
-    assert_equal(1, second_event[:severity])
-    assert_nil second_event[:message]
-    assert_nil second_event[:progname]
-    assert_equal({ backtrace: "backtrace", env: nil }, second_event[:opts])
-    assert_equal("yielded message", second_event[:block].call)
-  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 { |store| assert_equal "backtrace", store.calls[0][3][:backtrace] }
-  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
-
-  def test_logging_an_error_gets_backtrace_from_the_error
-    exception = error_instance(Exception)
-    std_err = error_instance(StandardError)
-    custom_err = error_instance(Class.new(StandardError))
-
-    @logger.error(exception)
-    @logger.fatal(std_err)
-    @logger.fatal(custom_err)
-
-    assert_equal exception.backtrace.join("\n"), @store.calls[0][3][:backtrace]
-    assert_equal std_err.backtrace.join("\n"), @store.calls[1][3][:backtrace]
-    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)
-    raise error_class.new
-  rescue error_class => e
-    e
-  end
-end