logster 2.4.2 → 2.5.0

data/client-app/package.json

@@ -18,20 +18,19 @@
     "test": "ember test"
   },
   "devDependencies": {
-    "jquery": "3.4.1",
     "@ember/optional-features": "^0.6.3",
     "broccoli-asset-rev": "^2.7.0",
     "ember-ajax": "^5.0.0",
-    "ember-cli": "~3.8.2",
+    "ember-cli": "^3.8.3",
     "ember-cli-app-version": "^3.2.0",
-    "ember-cli-babel": "^7.1.2",
-    "ember-cli-dependency-checker": "^3.1.0",
+    "ember-cli-babel": "^7.12.0",
+    "ember-cli-dependency-checker": "^3.2.0",
     "ember-cli-eslint": "^4.2.3",
-    "ember-cli-htmlbars": "^3.0.0",
+    "ember-cli-htmlbars": "^3.1.0",
     "ember-cli-htmlbars-inline-precompile": "^1.0.3",
     "ember-cli-inject-live-reload": "^1.8.2",
     "ember-cli-sri": "^2.1.1",
-    "ember-cli-template-lint": "^1.0.0-beta.1",
+    "ember-cli-template-lint": "^1.0.0-beta.3",
     "ember-cli-uglify": "^2.1.0",
     "ember-data": "~3.8.0",
     "ember-export-application-global": "^2.0.0",
@@ -39,19 +38,20 @@
     "ember-load-initializers": "^1.1.0",
     "ember-maybe-import-regenerator": "^0.1.6",
     "ember-qunit": "^3.4.1",
-    "ember-resolver": "^5.0.1",
-    "ember-source": "~3.8.0",
+    "ember-resolver": "^5.3.0",
+    "ember-source": "^3.8.3",
     "ember-welcome-page": "^3.2.0",
-    "eslint-plugin-ember": "^5.2.0",
+    "eslint-plugin-ember": "^5.4.0",
+    "jquery": "3.4.1",
     "loader.js": "^4.7.0",
-    "prettier": "^1.16.4",
-    "qunit-dom": "^0.8.0"
+    "prettier": "^1.19.1",
+    "qunit-dom": "^0.8.5"
   },
   "engines": {
     "node": "6.* || 8.* || >= 10.*"
   },
   "dependencies": {
-    "lodash": "~4.17.13",
+    "lodash": "^4.17.15",
     "moment": "~2.22.2"
   }
 }

data/client-app/tests/integration/components/env-tab-test.js

@@ -35,11 +35,18 @@ module("Integration | Component | env-tab", function(hooks) {
   setupRenderingTest(hooks);
 
   test("it renders", async function(assert) {
-    this.set("message", message);
-    await render(hbs`{{env-tab message=message}}`);
+    const callback = newPosition => this.set("envPosition", newPosition);
+    this.setProperties({
+      message,
+      callback,
+      envPosition: 0
+    });
+    await render(
+      hbs`{{env-tab message=message envChangedAction=callback currentEnvPosition=envPosition}}`
+    );
 
     assert.equal(
-      find(".env-number").textContent,
+      find(".current-number").textContent,
       "1/2",
       "shows the current over the total number of env objects"
     );
@@ -71,14 +78,21 @@ module("Integration | Component | env-tab", function(hooks) {
   });
 
   test("it works correctly", async function(assert) {
-    this.set("message", message);
-    await render(hbs`{{env-tab message=message}}`);
+    const callback = newPosition => this.set("envPosition", newPosition);
+    this.setProperties({
+      message,
+      callback,
+      envPosition: 0
+    });
+    await render(
+      hbs`{{env-tab message=message envChangedAction=callback currentEnvPosition=envPosition}}`
+    );
 
     const buttons = findAll("button.nav-btn");
     await click(buttons[2]);
 
     assert.equal(
-      find(".env-number").textContent,
+      find(".current-number").textContent,
       "2/2",
       "shows the current over the total number of env objects"
     );
@@ -108,8 +122,15 @@ module("Integration | Component | env-tab", function(hooks) {
       env_expandable_keys: ["env_key_2", "default_expanded"]
     });
     init();
-    this.set("message", message3);
-    await render(hbs`{{env-tab message=message}}`);
+    const callback = newPosition => this.set("envPosition", newPosition);
+    this.setProperties({
+      message: message3,
+      callback,
+      envPosition: 0
+    });
+    await render(
+      hbs`{{env-tab message=message envChangedAction=callback currentEnvPosition=envPosition}}`
+    );
 
     const trs = findAll(".env-table tr");
     const expandable = trs[0];

data/client-app/tests/integration/components/message-info-test.js

@@ -17,14 +17,22 @@ module("Integration | Component | message-info", function(hooks) {
   setupRenderingTest(hooks);
 
   test("it renders", async function(assert) {
+    const callback = newPosition => this.set("currentEnvPosition", newPosition);
     this.setProperties({
       actionsInMenu: true,
       showTitle: false,
-      message
+      envPosition: 0,
+      message,
+      callback
     });
 
     await render(
-      hbs`{{message-info currentMessage=message showTitle=showTitle actionsInMenu=actionsInMenu}}`
+      hbs`{{message-info
+            currentMessage=message
+            showTitle=showTitle
+            currentEnvPosition=envPosition
+            envChangedAction=callback
+            actionsInMenu=actionsInMenu}}`
     );
     let activeTab = find(".message-info .content.active pre");
     assert.equal(

data/lib/examples/sidekiq_logster_reporter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class SidekiqLogsterReporter
   def call(ex, context = {})
     # Pass context to Logster

data/lib/logster.rb

@@ -7,6 +7,8 @@ require 'logster/web'
 require 'logster/ignore_pattern'
 require 'logster/pattern'
 require 'logster/suppression_pattern'
+require 'logster/grouping_pattern'
+require 'logster/group'
 require 'logster/cache'
 
 if defined? Redis
@@ -17,8 +19,6 @@ else
 end
 
 module Logster
-  PATTERNS = [SuppressionPattern]
-
   def self.logger=(logger)
     @logger = logger
   end

data/lib/logster/base_store.rb

@@ -115,22 +115,39 @@ module Logster
 
     # increments the number of messages that have been suppressed by a pattern
     def increment_ignore_count(pattern)
+      not_implemented
     end
 
     # removes number of suppressed messages by a pattern
     def remove_ignore_count(pattern)
+      not_implemented
     end
 
     # returns a hash that maps patterns to the number of messages they
     # have suppressed
     def get_all_ignore_count
-      {}
+      not_implemented
     end
 
     def rate_limited?(ip_address, perform: false, limit: 60)
       not_implemented
     end
 
+    # find all pattern groups; returns an array of Logster::Group
+    def find_pattern_groups(load_messages: true)
+      not_implemented
+    end
+
+    # saves an instance of Logster::Group
+    def save_pattern_group(group)
+      not_implemented
+    end
+
+    # removes the Logster::Group instance associated with the given pattern
+    def remove_pattern_group(pattern)
+      not_implemented
+    end
+
     def report(severity, progname, msg, opts = {})
       return if (!msg || (String === msg && msg.empty?)) && skip_empty
       return if level && severity < level
@@ -164,7 +181,7 @@ module Logster
       end
 
       if Logster.config.enable_custom_patterns_via_ui || allow_custom_patterns
-        custom_ignore = @patterns_cache.fetch do
+        custom_ignore = @patterns_cache.fetch(Logster::SuppressionPattern::CACHE_KEY) do
           Logster::SuppressionPattern.find_all(store: self)
         end
         return if custom_ignore.any? do |pattern|
@@ -194,10 +211,29 @@ module Logster
         save message
         message
       end
+
+      message = similar || message
+
+      if Logster.config.enable_custom_patterns_via_ui || allow_custom_patterns
+        grouping_patterns = @patterns_cache.fetch(Logster::GroupingPattern::CACHE_KEY) do
+          Logster::GroupingPattern.find_all(store: self)
+        end
+
+        grouping_patterns.each do |pattern|
+          if message =~ pattern
+            group = find_pattern_groups() { |pat| pat == pattern }[0]
+            group ||= Logster::Group.new(pattern.inspect)
+            group.add_message(message)
+            save_pattern_group(group) if group.changed?
+            break
+          end
+        end
+      end
+      message
     end
 
-    def clear_suppression_patterns_cache
-      @patterns_cache.clear
+    def clear_patterns_cache(key)
+      @patterns_cache.clear(key)
     end
 
     private

data/lib/logster/cache.rb

@@ -1,20 +1,21 @@
+# frozen_string_literal: true
+
 module Logster
   class Cache
     def initialize(age = 2)
       @age = age
-      @hash = { created_at: Process.clock_gettime(Process::CLOCK_MONOTONIC) }
+      @hash = {}
     end
 
-    def fetch
-      if !@hash.key?(:data) || @hash[:created_at] + @age < Process.clock_gettime(Process::CLOCK_MONOTONIC)
-        @hash[:data] = yield
-        @hash[:created_at] = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    def fetch(key)
+      if !@hash.key?(key) || @hash[key][:created_at] + @age < Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        @hash[key] = { data: yield, created_at: Process.clock_gettime(Process::CLOCK_MONOTONIC) }
       end
-      @hash[:data]
+      @hash[key][:data]
     end
 
-    def clear
-      @hash.delete(:data)
+    def clear(key)
+      @hash.delete(key)
     end
   end
 end

data/lib/logster/defer_logger.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'logster/scheduler'
 
 module Logster

data/lib/logster/group.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Logster
+  class Group
+    MAX_SIZE = 100
+
+    attr_reader :key, :messages_keys, :timestamp, :messages
+    attr_accessor :changed
+
+    def initialize(key, messages_keys = [], timestamp: 0)
+      @key = key
+      @messages_keys = messages_keys || []
+      @timestamp = timestamp
+      @changed = true
+    end
+
+    def self.from_json(json)
+      hash = JSON.parse(json)
+      group = new(
+        hash["key"],
+        hash["messages_keys"],
+        timestamp: hash["timestamp"] || 0
+      )
+      group.changed = false
+      group
+    end
+
+    def self.max_size
+      (defined?(@max_size) && @max_size) || MAX_SIZE
+    end
+
+    def to_h
+      {
+        key: @key,
+        messages_keys: @messages_keys,
+        timestamp: @timestamp
+      }
+    end
+
+    def to_h_web
+      {
+        regex: @key,
+        count: self.count,
+        timestamp: @timestamp,
+        messages: @messages,
+        severity: -1,
+        group: true
+      }
+    end
+
+    def to_json(opts = nil)
+      JSON.fast_generate(self.to_h, opts)
+    end
+
+    def add_message(message)
+      if !@messages_keys.include?(message.key)
+        @messages_keys.unshift(message.key)
+        @changed = true
+      end
+      if @timestamp < message.timestamp
+        @timestamp = message.timestamp
+        @messages_keys.unshift(@messages_keys.slice!(@messages_keys.index(message.key)))
+        @changed = true
+      end
+      if self.count > max_size
+        @messages_keys.slice!(max_size..-1)
+        @changed = true
+      end
+    end
+
+    def remove_message(message)
+      index = @messages_keys.index(message.key)
+      if index
+        @messages_keys.slice!(index)
+        @changed = true
+      end
+    end
+
+    def messages=(messages)
+      messages.compact!
+      messages.uniq!(&:key)
+      if messages.size > 0
+        messages.sort_by!(&:timestamp)
+        messages.reverse!
+        messages.slice!(max_size..-1) if messages.size > max_size
+        @messages = messages
+        before = @messages_keys.sort
+        @messages_keys = @messages.map(&:key)
+        @timestamp = @messages[0].timestamp
+        @changed = before != @messages_keys.sort
+      else
+        @messages_keys = []
+        @messages = []
+        @timestamp = 0
+        @changed = true
+      end
+      @messages
+    end
+
+    def changed?
+      @changed
+    end
+
+    def count
+      @messages_keys.size
+    end
+
+    private
+
+    def max_size
+      self.class.max_size
+    end
+
+    GroupWeb = Struct.new(*%i[regex count timestamp messages row_id]) do
+      def to_json(opts = nil)
+        JSON.fast_generate(self.to_h.merge(severity: -1, group: true), opts)
+      end
+
+      def key
+        self.regex # alias for testing convenience
+      end
+    end
+  end
+end

data/lib/logster/grouping_pattern.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Logster
+  class GroupingPattern < Pattern
+    CACHE_KEY = :grouping
+    def self.set_name
+      "__LOGSTER__grouping_patterns_set".freeze
+    end
+
+    def save(args = {})
+      super
+      existing_groups = @store.find_pattern_groups
+      group = Logster::Group.new(self.to_s)
+      messages = @store.get_all_messages(with_env: false)
+      messages.select! do |m|
+        m.message =~ self.pattern && existing_groups.none? { |g| g.messages_keys.include?(m.key) }
+      end
+      group.messages = messages
+      @store.save_pattern_group(group) if group.changed?
+      @store.clear_patterns_cache(CACHE_KEY)
+    end
+
+    def destroy(clear_cache: true) # arg used in tests
+      super()
+      @store.remove_pattern_group(self.pattern)
+      @store.clear_patterns_cache(CACHE_KEY) if clear_cache
+    end
+  end
+end

data/lib/logster/ignore_pattern.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Logster
   class IgnorePattern