logster 2.10.1 → 2.11.2

data/client-app/package.json

@@ -43,6 +43,7 @@
     "ember-maybe-import-regenerator": "^0.1.6",
     "ember-qunit": "^4.6.0",
     "ember-resolver": "^7.0.0",
+    "ember-sinon-qunit": "^6.0.0",
     "ember-source": "^3.15.0",
     "eslint-plugin-ember": "^7.13.0",
     "eslint-plugin-node": "^10.0.0",
@@ -57,6 +58,6 @@
     "edition": "octane"
   },
   "dependencies": {
-    "moment": "~2.22.2"
+    "moment": "~2.29.2"
   }
 }

data/client-app/tests/unit/controllers/index-test.js

@@ -1,12 +1,30 @@
 import { module, test } from 'qunit';
 import { setupTest } from 'ember-qunit';
+import { default as MessageCollection } from "client-app/models/message-collection";
+import sinon from "sinon";
+import * as utilities from "client-app/lib/utilities";
 
-module('Unit | Controller | index', function(hooks) {
+module('Unit | Controller | index', function (hooks) {
   setupTest(hooks);
 
-  // Replace this with your real tests.
-  test('it exists', function(assert) {
-    let controller = this.owner.lookup('controller:index');
-    assert.ok(controller);
+  test('uses search param to filter results', function (assert) {
+    const controller = this.owner.lookup('controller:index');
+    const ajaxStub = sinon.stub(utilities, 'ajax')
+    const messages = MessageCollection.create();
+    const row1 = {"message": "error tomtom", "severity": 2, "key": "ce1f53b0cc"};
+    const row2 = {"message": "error steaky", "severity": 3, "key": "b083352825"};
+
+    messages.rows.addObjects([row1, row2]);
+    controller.set("model", messages)
+
+    assert.equal(controller.searchTerm, null, 'initial value is null');
+    assert.deepEqual(controller.model.rows, [row1, row2], 'all rows');
+
+    ajaxStub.callsFake(() => Promise.resolve({search: "tomtom", filter: [5], messages: []}));
+    controller.set("search", "tomtom");
+
+    assert.equal(controller.searchTerm, "tomtom", 'search sets search term');
+    assert.equal(ajaxStub.firstCall.args[0], "/messages.json", "get messages");
+    assert.deepEqual(ajaxStub.firstCall.args[1], {"data": {"filter": "5", "search": "tomtom"}}, "with correct terms");
   });
 });

data/lib/logster/logger.rb

@@ -4,7 +4,7 @@ require 'logger'
 
 module Logster
   class Logger < ::Logger
-    LOGSTER_ENV = "logster_env".freeze
+    LOGSTER_ENV = "logster_env"
 
     attr_accessor :store, :skip_store
     attr_reader :chained
@@ -12,21 +12,17 @@ module Logster
     def initialize(store)
       super(nil)
       @store = store
-      @override_levels = nil
       @chained = []
       @skip_store = false
+      @logster_override_level_key = "logster_override_level_#{object_id}"
     end
 
     def override_level=(val)
-      tid = Thread.current.object_id
-
-      ol = @override_levels
-      if val.nil? && ol && ol.key?(tid)
-        ol.delete(tid)
-        @override_levels = nil if ol.length == 0
-      elsif val
-        (@override_levels ||= {})[tid] = val
-      end
+      Thread.current[@logster_override_level_key] = val
+    end
+
+    def override_level
+      Thread.current[@logster_override_level_key]
     end
 
     def chain(logger)
@@ -55,8 +51,7 @@ module Logster
     end
 
     def level
-      ol = @override_levels
-      (ol && ol[Thread.current.object_id]) || @level
+      Thread.current[@logster_override_level_key] || @level
     end
 
     def add_with_opts(severity, message = nil, progname = progname(), opts = nil, &block)
@@ -74,9 +69,13 @@ module Logster
       # own methods don't show up as the first few frames in the backtrace
       if !opts || !opts.key?(:backtrace)
         opts ||= {}
-        backtrace = caller_locations
-        while backtrace.first.path.end_with?("/logger.rb")
-          backtrace.shift
+        backtrace = message.backtrace if message.kind_of?(::Exception)
+        backtrace ||= progname.backtrace if progname.kind_of?(::Exception)
+        if !backtrace
+          backtrace = caller_locations
+          while backtrace.first.path.end_with?("/logger.rb")
+            backtrace.shift
+          end
         end
         backtrace = backtrace.join("\n")
         opts[:backtrace] = backtrace

data/lib/logster/redis_store.rb

@@ -27,10 +27,10 @@ module Logster
         end
       end
 
-      @redis.multi do
-        @redis.hset(grouping_key, message.grouping_key, message.key)
-        @redis.rpush(list_key, message.key)
-        update_message(message, save_env: true)
+      @redis.multi do |pipeline|
+        pipeline.hset(grouping_key, message.grouping_key, message.key)
+        pipeline.rpush(list_key, message.key)
+        update_message(message, save_env: true, redis: pipeline)
       end
 
       trim
@@ -41,30 +41,30 @@ module Logster
 
     def delete(msg)
       groups = find_pattern_groups() { |pat| msg.message =~ pat }
-      @redis.multi do
+      @redis.multi do |pipeline|
         groups.each do |group|
           group.remove_message(msg)
-          save_pattern_group(group) if group.changed?
+          save_pattern_group(group, redis: pipeline) if group.changed?
         end
-        @redis.hdel(hash_key, msg.key)
-        delete_env(msg.key)
-        @redis.hdel(grouping_key, msg.grouping_key)
-        @redis.lrem(list_key, -1, msg.key)
+        pipeline.hdel(hash_key, msg.key)
+        delete_env(msg.key, redis: pipeline)
+        pipeline.hdel(grouping_key, msg.grouping_key)
+        pipeline.lrem(list_key, -1, msg.key)
       end
     end
 
     def bulk_delete(message_keys, grouping_keys)
       groups = find_pattern_groups(load_messages: true)
-      @redis.multi do
+      @redis.multi do |pipeline|
         groups.each do |group|
           group.messages = group.messages.reject { |m| message_keys.include?(m.key) }
-          save_pattern_group(group) if group.changed?
+          save_pattern_group(group, redis: pipeline) if group.changed?
         end
-        @redis.hdel(hash_key, message_keys)
-        @redis.hdel(grouping_key, grouping_keys)
+        pipeline.hdel(hash_key, message_keys)
+        pipeline.hdel(grouping_key, grouping_keys)
         message_keys.each do |k|
-          @redis.lrem(list_key, -1, k)
-          delete_env(k)
+          pipeline.lrem(list_key, -1, k)
+          delete_env(k, redis: pipeline)
         end
       end
     end
@@ -74,11 +74,11 @@ module Logster
       exists = @redis.hexists(hash_key, message.key)
       return false unless exists
 
-      @redis.multi do
-        @redis.hset(hash_key, message.key, message.to_json(exclude_env: true))
-        push_env(message.key, message.env_buffer) if message.has_env_buffer?
-        @redis.lrem(list_key, -1, message.key)
-        @redis.rpush(list_key, message.key)
+      @redis.multi do |pipeline|
+        pipeline.hset(hash_key, message.key, message.to_json(exclude_env: true))
+        push_env(message.key, message.env_buffer, redis: pipeline) if message.has_env_buffer?
+        pipeline.lrem(list_key, -1, message.key)
+        pipeline.rpush(list_key, message.key)
       end
       message.env_buffer = [] if message.has_env_buffer?
       check_rate_limits(message.severity)
@@ -188,11 +188,12 @@ module Logster
           .sort
           .map(&:key)
 
-        @redis.pipelined do
+        @redis.pipelined do |pipeline|
           sorted.each do |message_key|
-            @redis.rpush(list_key, message_key)
+            pipeline.rpush(list_key, message_key)
           end
         end
+
         find_pattern_groups(load_messages: true).each do |group|
           group.messages = group.messages.select { |m| sorted.include?(m.key) }
           save_pattern_group(group) if group.changed?
@@ -383,11 +384,11 @@ module Logster
       jsons
     end
 
-    def save_pattern_group(group)
+    def save_pattern_group(group, redis: @redis)
       if group.messages_keys.size == 0
-        @redis.hdel(pattern_groups_key, group.key)
+        redis.hdel(pattern_groups_key, group.key)
       else
-        @redis.hset(pattern_groups_key, group.key, group.to_json)
+        redis.hset(pattern_groups_key, group.key, group.to_json)
       end
     end
 
@@ -429,13 +430,13 @@ module Logster
       end
     end
 
-    def update_message(message, save_env: false)
-      @redis.hset(hash_key, message.key, message.to_json(exclude_env: true))
-      push_env(message.key, message.env) if save_env
+    def update_message(message, save_env: false, redis: @redis)
+      redis.hset(hash_key, message.key, message.to_json(exclude_env: true))
+      push_env(message.key, message.env, redis: redis) if save_env
       if message.protected
-        @redis.sadd(protected_key, message.key)
+        redis.sadd(protected_key, message.key)
       else
-        @redis.srem(protected_key, message.key)
+        redis.srem(protected_key, message.key)
       end
     end
 
@@ -640,15 +641,15 @@ module Logster
       rate_limiter
     end
 
-    def push_env(message_key, env)
+    def push_env(message_key, env, redis: @redis)
       prefixed = env_prefix(message_key)
       env = [env] unless Array === env
-      @redis.lpush(prefixed, env.map(&:to_json).reverse)
-      @redis.ltrim(prefixed, 0, Logster.config.max_env_count_per_message - 1)
+      redis.lpush(prefixed, env.map(&:to_json).reverse)
+      redis.ltrim(prefixed, 0, Logster.config.max_env_count_per_message - 1)
     end
 
-    def delete_env(message_key)
-      @redis.del(env_prefix(message_key))
+    def delete_env(message_key, redis: @redis)
+      redis.del(env_prefix(message_key))
     end
 
     def env_unprefix(key, with_namespace: false)

data/lib/logster/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Logster
-  VERSION = "2.10.1"
+  VERSION = "2.11.2"
 end

data/test/logster/test_logger.rb

@@ -26,6 +26,12 @@ class TestLogger < Minitest::Test
   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" })
@@ -106,4 +112,26 @@ class TestLogger < Minitest::Test
     @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
+
+  private
+
+  def error_instance(error_class)
+    raise error_class.new
+  rescue error_class => e
+    e
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logster
 version: !ruby/object:Gem::Version
-  version: 2.10.1
+  version: 2.11.2
 platform: ruby
 authors:
 - Sam Saffron
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-12-01 00:00:00.000000000 Z
+date: 2022-04-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler