logster 1.3.4 → 1.4.0.pre

data/client-app/app/templates/components/env-tab.hbs

@@ -0,0 +1,10 @@
+{{#if isEnvArray}}
+  <div class="nav-controls">
+    <button disabled={{disableBackButtons}} {{action "bigJump" "back"}} class="btn nav-btn no-text"><i class="fa fa-fast-backward"></i></button>
+    <button disabled={{disableBackButtons}} {{action "takeStep" "back"}} class="btn nav-btn no-text"><i class="fa fa-backward"></i></button>
+    <span class="env-number">{{current}}/{{message.env.length}}</span>
+    <button disabled={{disableForwardButtons}} {{action "takeStep" "front"}} class="btn nav-btn no-text"><i class="fa fa-forward"></i></button>
+    <button disabled={{disableForwardButtons}} {{action "bigJump" "front"}} class="btn nav-btn no-text"><i class="fa fa-fast-forward"></i></button>
+  </div>
+{{/if}}
+{{{html}}}

data/client-app/app/templates/components/message-info.hbs

@@ -21,7 +21,7 @@
         {{#if showTitle}}
           <h3>Env</h3>
         {{/if}}
-        {{{currentMessage.envTable}}}
+        {{env-tab message=currentMessage}}
       {{/tab-contents}}
     {{/if}}
   {{/tabbed-section}}

data/client-app/app/templates/components/message-row.hbs

@@ -1,17 +1,15 @@
-<td class="count">
+<div class="count">
   {{#if model.showCount}}
-    <span>{{model.count}}</span>
+    {{model.count}}
   {{/if}}
-</td>
-<td class="severity">{{{model.glyph}}}</td>
-<td class="message-body">
-  <div class="message">
-    {{model.displayMessage}}
-  </div>
-</td>
-<td class='protected'>
+</div>
+<div class="severity">{{{model.glyph}}}</div>
+<div class="message-body">
+  {{model.displayMessage}}
+</div>
+<div class='protected'>
   {{#if model.protected}}
     <i title="message is protected, clearing will not remove it" class='fa fa-lock'></i>
   {{/if}}
-</td>
-<td class="time">{{time-formatter timestamp=model.timestamp}}</td>
+</div>
+<div class="time">{{time-formatter timestamp=model.timestamp}}</div>

data/client-app/app/templates/index.hbs

@@ -1,25 +1,18 @@
 <div id='top-panel'>
-  <table id='log-table'>
-    <thead>
-      <tr>
-        <th class="count"></th>
-        <th class="severity"></th>
-        <th class="info"></th>
-        <th class="protected"></th>
-        <th class="time"></th>
-      </tr>
-    </thead>
-    <tbody>
+  <div id="log-table">
     {{#if model.moreBefore}}
-      <tr {{action "showMoreBefore"}} class="show-more">
-        <td colspan=5>select to see {{model.totalBefore}} more</td>
-      </tr>
+      <div {{action "showMoreBefore"}} class="show-more">
+        {{#if model.hideCountInLoadMore}}
+          Load more
+        {{else}}
+          Select to see {{model.totalBefore}} more
+        {{/if}}
+      </div>
     {{/if}}
     {{#each model.messages as |message|}}
       {{message-row model=message selectedMessage=(action "selectMessage")}}
     {{/each}}
-    </tbody>
-  </table>
+  </div>
 </div>
 <div id="bottom-panel">
   {{message-info

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

@@ -0,0 +1,73 @@
+import { module, test } from 'qunit';
+import { setupRenderingTest } from 'ember-qunit';
+import { render, find, findAll, click } from '@ember/test-helpers';
+import hbs from 'htmlbars-inline-precompile';
+import Message from "client-app/models/message";
+
+const message = Message.create({
+  env: [
+    { a: "aa", b: "bb" },
+    { c: "cc", d: "dd" }
+  ]
+})
+
+const message2 = Message.create({
+  env: { e: "ee", f: "ff" }
+});
+
+function reduceToContent(node) {
+  return Array.from(node.childNodes).reduce((ac, cr) => `${ac.textContent}: ${cr.textContent}`);
+}
+
+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}}`);
+
+    assert.equal(find(".env-number").textContent, "1/2", "shows the current over the total number of env objects");
+    let trs = findAll("tr");
+    assert.equal(trs.length, 2);
+    assert.equal(reduceToContent(trs[0]), 'a: aa', "has the right content");
+    assert.equal(reduceToContent(trs[1]), 'b: bb', "has the right content");
+
+    const buttons = findAll("button.nav-btn");
+    // at first page, you can't go back
+    assert.ok(buttons[0].disabled, "back buttons are disabled");
+    assert.ok(buttons[1].disabled, "back buttons are disabled");
+
+    assert.notOk(buttons[2].disabled, "forward buttons are not disabled");
+    assert.notOk(buttons[3].disabled, "forward buttons are not disabled");
+
+    this.set("message", message2);
+    assert.dom("button").doesNotExist("doesn't show buttons for non-array env");
+
+    trs = findAll("tr");
+    assert.equal(trs.length, 2);
+    assert.equal(reduceToContent(trs[0]), 'e: ee', "has the right content");
+    assert.equal(reduceToContent(trs[1]), 'f: ff', "has the right content");
+  });
+
+  test('it works correctly', async function(assert) {
+    this.set("message", message);
+    await render(hbs`{{env-tab message=message}}`);
+
+    const buttons = findAll("button.nav-btn");
+    await click(buttons[2]);
+
+    assert.equal(find(".env-number").textContent, "2/2", "shows the current over the total number of env objects");
+
+    const trs = findAll("tr");
+    assert.equal(trs.length, 2);
+    assert.equal(reduceToContent(trs[0]), 'c: cc', "has the right content");
+    assert.equal(reduceToContent(trs[1]), 'd: dd', "has the right content");
+
+    // at last page, you can't go forward but you can go back
+    assert.notOk(buttons[0].disabled, "back buttons are not disabled");
+    assert.notOk(buttons[1].disabled, "back buttons are not disabled");
+
+    assert.ok(buttons[2].disabled, "forward buttons are disabled");
+    assert.ok(buttons[3].disabled, "forward buttons are disabled");
+  });
+});

data/lib/logster/base_store.rb

@@ -1,4 +1,3 @@
-
 module Logster
   class BaseStore
 
@@ -79,12 +78,11 @@ module Logster
       return if (!msg || (String === msg && msg.empty?)) && skip_empty
       return if level && severity < level
 
-      message = Logster::Message.new(severity, progname, msg, opts[:timestamp])
+      message = Logster::Message.new(severity, progname, msg, opts[:timestamp], count: opts[:count])
 
       env = opts[:env] || {}
       backtrace = opts[:backtrace]
-
-      if env[:backtrace]
+      if Hash === env && env[:backtrace]
         # Special - passing backtrace through env
         backtrace = env.delete(:backtrace)
       end
@@ -110,7 +108,6 @@ module Logster
       end
 
       if similar
-        similar.count += 1
         similar.merge_similar_message(message)
 
         replace_and_bump similar

data/lib/logster/ignore_pattern.rb

@@ -35,7 +35,7 @@ module Logster
         when Regexp
           message.to_s =~ pattern
         when String
-          message.to_s.downcase =~ Regexp.new(pattern.downcase, Regexp::IGNORECASE)
+          message.to_s =~ Regexp.new(pattern, Regexp::IGNORECASE)
         when Hash
           if Hash === message
             compare_hash(message, pattern)

data/lib/logster/logger.rb

@@ -57,7 +57,7 @@ module Logster
       (ol && ol[Thread.current.object_id]) || @level
     end
 
-    def add_with_opts(severity, message, progname, opts=nil, &block)
+    def add_with_opts(severity, message, progname=progname(), opts=nil, &block)
       if severity < level
         return true
       end

data/lib/logster/message.rb

@@ -23,14 +23,14 @@ module Logster
 
     attr_accessor :timestamp, :severity, :progname, :message, :key, :backtrace, :count, :env, :protected, :first_timestamp
 
-    def initialize(severity, progname, message, timestamp = nil, key = nil)
+    def initialize(severity, progname, message, timestamp = nil, key = nil, count: 1)
       @timestamp = timestamp || get_timestamp
       @severity = severity
       @progname = progname
       @message = message
       @key = key || SecureRandom.hex
       @backtrace = nil
-      @count = 1
+      @count = count || 1
       @protected = false
       @first_timestamp = nil
     end
@@ -80,7 +80,14 @@ module Logster
 
     def populate_from_env(env)
       env ||= {}
-      @env = Message.populate_from_env(self.class.default_env.merge env)
+      if Array === env
+        env = env.map do |single_env|
+          self.class.default_env.merge(single_env)
+        end
+      else
+        env = self.class.default_env.merge(env)
+      end
+      @env = Message.populate_from_env(env)
     end
 
     def self.default_env
@@ -104,8 +111,13 @@ module Logster
 
     # todo - memoize?
     def solved_keys
-      if (versions=env["application_version"]) &&
-          (backtrace && backtrace.length > 0)
+      if Array === env
+        versions = env.map { |single_env| single_env["application_version"] }
+      else
+        versions = env["application_version"]
+      end
+
+      if versions && backtrace && backtrace.length > 0
         versions = [versions] if String === versions
 
         versions.map do |version|
@@ -121,35 +133,49 @@ module Logster
     def merge_similar_message(other)
       self.first_timestamp ||= self.timestamp
       self.timestamp = [self.timestamp,other.timestamp].max
+      self.count += other.count || 1
+
       other_env = JSON.load JSON.fast_generate other.env
-      other_env.keys.each do |env_key|
-        self.env[env_key] = Message.env_merge_helper(self.env[env_key], other_env[env_key])
+      if Array === self.env
+        Array === other_env ? self.env.concat(other_env) : self.env << other_env
+      else
+        Array === other_env ? self.env = [self.env, *other_env] : self.env = [self.env, other_env]
       end
     end
 
     def self.populate_from_env(env)
+      if Array === env
+        env.map do |single_env|
+          self.populate_env_helper(single_env)
+        end
+      else
+        self.populate_env_helper(env)
+      end
+    end
+
+    def self.populate_env_helper(env)
       env[LOGSTER_ENV] ||= begin
-          unless env.include? "rack.input"
-            # Not a web request
-            return env
-          end
-          scrubbed = default_env
-          request = Rack::Request.new(env)
-          params = {}
-          request.params.each do |k,v|
-            if k.include? "password"
-              params[k] = "[redacted]"
-            elsif Array === v
-              params[k] = v[0..20]
-            else
-              params[k] = v && v[0..100]
-            end
+        unless env.include? "rack.input"
+          # Not a web request
+          return env
+        end
+        scrubbed = default_env
+        request = Rack::Request.new(env)
+        params = {}
+        request.params.each do |k,v|
+          if k.include? "password"
+            params[k] = "[redacted]"
+          elsif Array === v
+            params[k] = v[0..20]
+          else
+            params[k] = v && v[0..100]
           end
-          scrubbed["params"] = params if params.length > 0
-          ALLOWED_ENV.map{ |k|
-           scrubbed[k] = env[k] if env[k]
-          }
-          scrubbed
+        end
+        scrubbed["params"] = params if params.length > 0
+        ALLOWED_ENV.map{ |k|
+         scrubbed[k] = env[k] if env[k]
+        }
+        scrubbed
       end
     end
 

data/lib/logster/redis_store.rb

@@ -423,18 +423,69 @@ module Logster
       [start, finish]
     end
 
+    def get_search(search)
+      exclude = false
+      if String === search && search[0] == "-"
+        exclude = true
+        search = search.sub("-", "")
+      end
+      [search, exclude]
+    end
+
     def filter_search(row, search)
+      search, exclude = get_search(search)
       return row unless row && search
 
-      if Regexp === search
-        row if row.message =~ search
-      elsif search[0] == "-"
-        exclude = search.sub('-', '')
-        row unless row.message.include?(exclude)
-      elsif row.message.include?(search)
-        row
+      if exclude
+        row if !(row =~ search) && filter_env!(row, search, exclude)
+      else
+        row if row =~ search || filter_env!(row, search)
+      end
+    end
+
+    def filter_env!(message, search, exclude = false)
+      if Array === message.env
+        array_env_matches?(message, search, exclude)
+      else
+        if exclude
+          !env_matches?(message.env, search)
+        else
+          env_matches?(message.env, search)
+        end
+      end
+    end
+
+    def env_matches?(env, search)
+      return false unless env && search
+
+      env.values.any? do |value|
+        if Hash === value
+          env_matches?(value, search)
+        else
+          case search
+            when Regexp
+              value.to_s =~ search
+            when String
+              value.to_s =~ Regexp.new(search, Regexp::IGNORECASE)
+            else
+              false
+          end
+        end
       end
+    end
 
+    def array_env_matches?(message, search, exclude)
+      matches = message.env.select do |env|
+        if exclude
+          !env_matches?(env, search)
+        else
+          env_matches?(env, search)
+        end
+      end
+      return false if matches.empty?
+      message.env = matches
+      message.count = matches.size
+      true
     end
 
     def check_rate_limits(severity)

data/lib/logster/version.rb

@@ -1,3 +1,3 @@
 module Logster
-  VERSION = "1.3.4"
+  VERSION = "1.4.0.pre"
 end

data/test/logster/test_message.rb

@@ -18,6 +18,43 @@ class TestMessage < MiniTest::Test
 
     assert_equal(20, msg1.timestamp)
     assert_equal(10, msg1.first_timestamp)
+
+    assert Array === msg1.env
+    assert_equal(msg1.env.size, 2)
+    assert({ "a" => "1", "b" => "2" } <= msg1.env[0])
+    assert({ "a" => "2", "c" => "3" } <= msg1.env[1])
+  end
+
+  def test_merge_messages_both_with_array_envs
+    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.env = [{ e: "ee", f: "ff" }, { g: "gg", h: "hh" }]
+
+    msg1.merge_similar_message(msg2) 
+    msg1 = Logster::Message.from_json(msg1.to_json)
+
+    # new env should be an array, but it should never have
+    # another array of envs within itself (hence flatten(1))
+    assert_equal(msg1.env.size, 4)
+    assert_equal(msg1.env.map(&:keys).flatten(1), %w{a b c d e f g h})
+    assert_equal(msg1.env.map(&:values).flatten(1), %w{aa bb cc dd ee ff gg hh})
+  end
+
+  def test_merge_messages_one_with_array_envs
+    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.env = { e: "ee", f: "ff" }
+
+    msg1.merge_similar_message(msg2) 
+    msg1 = Logster::Message.from_json(msg1.to_json)
+
+    assert_equal(msg1.env.size, 3)
+    assert_equal(msg1.env.map(&:keys).flatten(1), %w{a b c d e f})
+    assert_equal(msg1.env.map(&:values).flatten(1), %w{aa bb cc dd ee ff})
   end
 
   def test_adds_application_version
@@ -31,4 +68,26 @@ class TestMessage < MiniTest::Test
     Logster.config.application_version = nil
   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)
+    msg2.env = {}
+
+    assert_equal(msg1.grouping_key, msg2.grouping_key)
+
+    msg1.merge_similar_message(msg2)
+    msg1 = Logster::Message.from_json(msg1.to_json)
+    assert_equal(msg1.count, 15 + 13)
+  end
+
+  def test_populate_from_env_works_on_array
+    msg = Logster::Message.new(0, '', 'test', 10)
+    hash = { "custom_key" => "key" }
+    msg.populate_from_env([hash])
+
+    msg = Logster::Message.from_json(msg.to_json)
+    assert Array === msg.env
+    assert_equal(msg.env.size, 1)
+    assert hash <= msg.env[0]
+  end
 end