logster 1.4.0.pre → 2.0.0.pre

data/test/logster/test_redis_store.rb

@@ -14,11 +14,13 @@ class TestRedisStore < Minitest::Test
   end
 
   def test_delete
-    msg = @store.report(Logger::WARN, "test", "testing")
+    env = { test_env: "this is env" }
+    msg = @store.report(Logger::WARN, "test", "testing", env: env)
     @store.delete(msg)
     latest = @store.latest
 
-    assert_equal(0,latest.length)
+    assert_equal(0, latest.length)
+    assert_nil(@store.get_env(msg.key))
   end
 
   def test_latest
@@ -78,25 +80,188 @@ class TestRedisStore < Minitest::Test
   end
 
   def test_get
-    a_message = @store.report(Logger::WARN, "test", "A")
+    a_env = { "a_message" => "A MESSAGE" }
+    a_message = @store.report(Logger::WARN, "test", "A", env: a_env)
     b_message = @store.report(Logger::WARN, "test", "B")
     @store.report(Logger::WARN, "test", "C")
 
-    assert_equal("A", @store.get(a_message.key).message)
-    assert_equal("B", @store.get(b_message.key).message)
+    a_message = @store.get(a_message.key)
+    assert_equal("A", a_message.message)
+    assert_equal("B", b_message.message)
+    assert(a_env <= a_message.env)
+
+    a_message = @store.get(a_message.key, load_env: false)
+    assert_equal("A", a_message.message)
+    assert_nil(a_message.env)
+  end
+
+  def test_save_saves_env_separately
+    env = { "myenv" => "thisisenv" }
+    message = @store.report(Logger::WARN, "test", "title", env: env)
+    message = @store.get(message.key, load_env: false)
+    assert_nil(message.env)
+
+    message = @store.get(message.key)
+    assert(env <= message.env)
+
+    assert(env <= @store.get_env(message.key))
+  end
+
+  def test_bulk_get
+    keys = []
+
+    5.times do |n|
+      env = n == 0 ? nil : { "test_#{n}" => "envsss" }
+      keys << @store.report(Logger::WARN, "progname", "test_#{n}", env: env).key
+    end
+
+    messages = @store.bulk_get(keys)
+
+    5.times do |n|
+      msg = messages[n]
+      assert_equal("test_#{n}", msg.message)
+      if n == 0
+        assert_equal(Logster::Message.default_env, msg.env)
+      else
+        assert({ "test_#{n}" => "envsss" } <= msg.env)
+      end
+    end
+  end
+
+  def test_get_env
+    env = { "my_little_env" => "some value" }
+    message = @store.report(Logger::WARN, "test", "A", env: env)
+    assert(env <= @store.get_env(message.key))
+    assert_nil(@store.get_env("nonexistentkey"))
+  end
+
+  def test_replace_and_bump
+    old_env = { "old_env" => "old value" }
+    message = @store.report(Logger::WARN, "test", "A", env: old_env)
+
+    unsaved_env = { "unsaved_env" => "lost value" }
+    message.env = unsaved_env
+
+    @store.replace_and_bump(message, save_env: false)
+
+    message = @store.get(message.key)
+    assert(old_env <= message.env)
+    refute(unsaved_env <= message.env)
+
+    saved_env = { "saved_env" => "saved value!" }
+    message.env = saved_env
+
+    @store.replace_and_bump(message)
+
+    message = @store.get(message.key)
+    assert(saved_env == message.env)
+  end
+
+  def test_backward_compatibility_no_loss_of_data
+    # previously we were storing env samples as a part of the main message json
+    # now we've switched to storing samples separately from the main message
+    # we need to make we don't lose env data of messages stored the old way
+    # when we migrate to the new system
+
+    # it probably makes sense to remove this test after a while (say 6-12 months)
+
+    Logster.config.allow_grouping = true
+    backtrace = "fake backtrace"
+    env = { "some_env" => "some env" }
+    message = Logster::Message.new(Logger::WARN, "", "title", count: 60)
+    message.env = env
+    message.backtrace = backtrace
+
+    @store.save(message)
+
+    # hack to force env to be stored with the main message json
+    @store.redis.hset(@store.send("hash_key"), message.key, message.to_json(exclude_env: false))
+
+    another_env = { "another_env" => "more env" }
+    message = @store.report(Logger::WARN, "", "title", backtrace: backtrace, env: another_env)
+    message = @store.get(message.key)
+
+    assert(env <= message.env)
+    assert_equal(61, message.count)
+    # another_env is not merged cause count is 60, only the count is updated
+
+    # make sure we are now storing env samples separately
+    message = @store.get(message.key, load_env: false)
+    assert_nil(message.env)
+  ensure
+    Logster.config.allow_grouping = false
+  end
+
+  def test_backward_compatibility_no_loss_of_data_2
+    # same story as the test above, just a bit different
+
+    Logster.config.allow_grouping = true
+    backtrace = "fake backtrace"
+    env = { "some_env" => "some env" }
+    message = Logster::Message.new(Logger::WARN, "", "title")
+    message.env = env
+    message.backtrace = backtrace
+
+    @store.save(message)
+
+    # hack to force env to be stored with the main message json
+    @store.redis.hset(@store.send("hash_key"), message.key, message.to_json(exclude_env: false))
+
+    another_env = { "another_env" => "more env" }
+    message = @store.report(Logger::WARN, "", "title", backtrace: backtrace, env: another_env)
+    message = @store.get(message.key)
+
+    assert_instance_of(Array, message.env)
+    assert(env <= message.env[0])
+    assert(another_env <= message.env[1])
+    assert_equal(2, message.env.size)
+    assert_equal(2, message.count)
+
+    # make sure we are now storing env samples separately
+    message = @store.get(message.key, load_env: false)
+    assert_nil(message.env)
+  ensure
+    Logster.config.allow_grouping = false
+  end
+
+  def test_merging_performance
+    Logster.config.allow_grouping = true
+    backtrace = "fake backtrace"
+    env = { "some_env" => "some env" }
+    another_env = { "another_env" => "more env" }
+    yet_another_env = { "moaar_env" => "more env" }
+
+    @store.report(Logger::WARN, "", "title", backtrace: backtrace, env: env, count: 49)
+
+    message = @store.report(Logger::WARN, "", "title", backtrace: backtrace, env: another_env)
+    assert_instance_of(Array, message.env)
+    assert_equal(2, message.env.size)
+    assert(env <= message.env[0])
+    assert(another_env <= message.env[1])
+
+    message = @store.report(Logger::WARN, "", "title", backtrace: backtrace, env: yet_another_env)
+    # we don't need to load env from redis cause we don't
+    # need to merge new env samples if count is 50 or more
+    assert_nil(message.env)
+  ensure
+    Logster.config.allow_grouping = false
   end
 
   def test_backlog
+    env = { "backlog_test" => "BACKLOG" }
     @store.max_backlog = 1
+    deleted_msg = @store.report(Logger::WARN, "test", "A")
     @store.report(Logger::WARN, "test", "A")
     @store.report(Logger::WARN, "test", "A")
-    @store.report(Logger::WARN, "test", "A")
-    @store.report(Logger::WARN, "test", "B")
+    @store.report(Logger::WARN, "test", "B", env: env)
 
     latest = @store.latest
 
     assert_equal(1, latest.length)
     assert_equal("B", latest[0].message)
+    assert(env <= latest[0].env)
+    assert_nil(@store.get(deleted_msg.key))
+    assert_nil(@store.get_env(deleted_msg.key))
   end
 
   def test_save_unsave
@@ -127,17 +292,18 @@ class TestRedisStore < Minitest::Test
   end
 
   def test_clear
+    env = { "clear_env" => "cllleear" }
     @store.max_backlog = 25
-    a_message = @store.report(Logger::WARN, "test", "A", timestamp: Time.now - (24*60*60))
+    a_message = @store.report(Logger::WARN, "test", "A", timestamp: Time.now - (24 * 60 * 60), env: env)
     @store.protect a_message.key
     20.times do
-      @store.report(Logger::WARN, "test", "B")
+      @store.report(Logger::WARN, "test", "B", env: env)
     end
-    c_message = @store.report(Logger::WARN, "test", "C", timestamp: Time.now + (24*60*60))
+    c_message = @store.report(Logger::WARN, "test", "C", timestamp: Time.now + (24 * 60 * 60), env: env)
     @store.protect c_message.key
-    d_message = @store.report(Logger::WARN, "test", "D")
+    d_message = @store.report(Logger::WARN, "test", "D", env: env)
     10.times do
-      @store.report(Logger::WARN, "test", "E")
+      @store.report(Logger::WARN, "test", "E", env: env)
     end
 
     latest = @store.latest
@@ -147,8 +313,10 @@ class TestRedisStore < Minitest::Test
 
     # Protected messages are still accessible by their key
     assert_equal("C", @store.get(c_message.key).message)
+    assert(env <= @store.get_env(c_message.key))
     # Unprotected messages are gone
     assert_nil(@store.get(d_message.key))
+    assert_nil(@store.get_env(d_message.key))
 
     # The latest list is rebuilt with protected messages, earliest first
     # Including messages that previously fell off (A)
@@ -156,6 +324,8 @@ class TestRedisStore < Minitest::Test
     assert_equal(2, latest.length)
     assert_equal("A", latest[0].message)
     assert_equal("C", latest[1].message)
+    assert(env <= latest[0].env)
+    assert(env <= latest[1].env)
   end
 
   def test_hash_cleanup
@@ -194,7 +364,7 @@ class TestRedisStore < Minitest::Test
     @store.report(Logger::ERROR, "test", "E")
     # respects after
     latest = @store.latest(severity: [Logger::ERROR, Logger::WARN], limit: 2, after: latest[1].key)
-    assert_equal(1, latest.length);
+    assert_equal(1, latest.length)
   end
 
   def test_search
@@ -277,9 +447,9 @@ class TestRedisStore < Minitest::Test
     # any hashes that don't match should be stripped from the env
     # array but only temporarily until it's sent to the client
     # env array should remain untouched in redis memory
-    assert_equal(["business5"], messages[0].env.map { |env| env["cluster"]})
+    assert_equal(["business5"], messages[0].env.map { |env| env["cluster"] })
     assert_equal(1, messages[0].count)
-    assert_equal(["business2"], messages[1].env.map { |env| env["cluster"]})
+    assert_equal(["business2"], messages[1].env.map { |env| env["cluster"] })
     assert_equal(1, messages[1].count)
 
     m1 = @store.get(m1_key)
@@ -309,7 +479,7 @@ class TestRedisStore < Minitest::Test
       @store.ignore = [
           Logster::IgnorePattern.new("business")
       ]
-      message2 = @store.report(Logger::WARN, "", "my error", env: { cluster: "business17", backtrace: backtrace })
+      @store.report(Logger::WARN, "", "my error", env: { cluster: "business17", backtrace: backtrace })
 
       message = @store.get(message.key)
       assert(Array === message.env)
@@ -335,9 +505,9 @@ class TestRedisStore < Minitest::Test
     messages = @store.latest(search: "-business")
     assert_equal(2, messages.size)
 
-    assert_equal(["standard3"], messages[0].env.map { |env| env["cluster"]})
+    assert_equal(["standard3"], messages[0].env.map { |env| env["cluster"] })
     assert_equal(1, messages[0].count)
-    assert_equal(["standard7"], messages[1].env.map { |env| env["cluster"]})
+    assert_equal(["standard7"], messages[1].env.map { |env| env["cluster"] })
     assert_equal(1, messages[1].count)
   end
 
@@ -385,7 +555,7 @@ class TestRedisStore < Minitest::Test
     assert_equal(1, @store.latest.count)
 
     @store.report(Logger::WARN, "application", "test error1", backtrace: "backtrace1")
-    @store.report(Logger::WARN, "application", "test error1", backtrace: "backtrace1", env: { "application_version" => "xyz"})
+    @store.report(Logger::WARN, "application", "test error1", backtrace: "backtrace1", env: { "application_version" => "xyz" })
 
     assert_equal(2, @store.latest.count)
 
@@ -395,15 +565,15 @@ class TestRedisStore < Minitest::Test
 
   def test_solve_grouped
     Logster.config.allow_grouping = true
-    @store.report(Logger::WARN, "application", "test error1", backtrace: "backtrace1", env: { "application_version" => "xyz"})
-    m = @store.report(Logger::WARN, "application", "test error1", backtrace: "backtrace1", env: { "application_version" => "efg"})
+    @store.report(Logger::WARN, "application", "test error1", backtrace: "backtrace1", env: { "application_version" => "xyz" })
+    m = @store.report(Logger::WARN, "application", "test error1", backtrace: "backtrace1", env: { "application_version" => "efg" })
 
     assert_equal(1, @store.latest.count)
 
     @store.solve(m.key)
 
-    @store.report(Logger::WARN, "application", "test error1", backtrace: "backtrace1", env: { "application_version" => "xyz"})
-    @store.report(Logger::WARN, "application", "test error1", backtrace: "backtrace1", env: { "application_version" => "efg"})
+    @store.report(Logger::WARN, "application", "test error1", backtrace: "backtrace1", env: { "application_version" => "xyz" })
+    @store.report(Logger::WARN, "application", "test error1", backtrace: "backtrace1", env: { "application_version" => "efg" })
 
     assert_equal(0, @store.latest.count)
 
@@ -412,7 +582,7 @@ class TestRedisStore < Minitest::Test
   end
 
   def test_clears_solved
-    m = @store.report(Logger::WARN, "application", "test error2", backtrace: "backtrace1", env: {"application_version" => "abc"})
+    m = @store.report(Logger::WARN, "application", "test error2", backtrace: "backtrace1", env: { "application_version" => "abc" })
     @store.solve(m.key)
 
     assert_equal(1, @store.solved.length)
@@ -423,7 +593,7 @@ class TestRedisStore < Minitest::Test
 
   def test_solving_with_some_missing_version
 
-    m=@store.report(Logger::WARN, "application", "test error1", backtrace: "backtrace1", env: { "application_version" => "xyz"})
+    m = @store.report(Logger::WARN, "application", "test error1", backtrace: "backtrace1", env: { "application_version" => "xyz" })
     @store.report(Logger::WARN, "application", "test error1", backtrace: "backtrace1")
 
     @store.solve(m.key)
@@ -432,17 +602,17 @@ class TestRedisStore < Minitest::Test
   end
 
   def test_env
-    env = Rack::MockRequest.env_for("/test").merge({
+    env = Rack::MockRequest.env_for("/test").merge(
       "HTTP_HOST" => "www.site.com",
       "HTTP_USER_AGENT" => "SOME WHERE"
-    })
+    )
     orig = env.dup
     orig["test"] = "tests"
     orig["test1"] = "tests1"
-    Logster.add_to_env(env,"test","tests")
-    Logster.add_to_env(env,"test1","tests1")
+    Logster.add_to_env(env, "test", "tests")
+    Logster.add_to_env(env, "test1", "tests1")
 
-    orig.delete_if do |k,v|
+    orig.delete_if do |k, v|
       !%w{
         HTTP_HOST
         REQUEST_METHOD

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logster
 version: !ruby/object:Gem::Version
-  version: 1.4.0.pre
+  version: 2.0.0.pre
 platform: ruby
 authors:
 - UI for viewing logs in Rack
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-09 00:00:00.000000000 Z
+date: 2019-01-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -122,6 +122,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.61.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.61.1
 description: UI for viewing logs in Rack
 email:
 - sam.saffron@gmail.com
@@ -130,6 +144,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rubocop.yml"
 - ".travis.yml"
 - CHANGELOG.md
 - Gemfile