logster 1.3.0 → 1.3.1

data/lib/logster/base_store.rb

@@ -1,130 +1,130 @@
-
-module Logster
-  class BaseStore
-
-    attr_accessor :level, :max_retention, :skip_empty, :ignore
-
-    def initialize
-      @max_retention = 60 * 60 * 24 * 7
-      @skip_empty = true
-    end
-
-    # Save a new message at the front of the latest list.
-    def save(message)
-      not_implemented
-    end
-
-    # Modify the saved message to the given one (identified by message.key) and bump it to the top of the latest list
-    def replace_and_bump(message)
-      not_implemented
-    end
-
-    # Check if another message with the same grouping_key is already stored.
-    # Returns the similar message's message.key
-    def similar_key(message)
-      not_implemented
-    end
-
-    # The number of messages currently stored.
-    def count
-      not_implemented
-    end
-
-    # Delete all unprotected messages in the store.
-    def clear
-      not_implemented
-    end
-
-    # Delete all messages, including protected messages.
-    def clear_all
-      not_implemented
-    end
-
-    # Get a message by its message_key
-    def get(message_key)
-      not_implemented
-    end
-
-    # Mark a message as protected; i.e. it is not deleted by the #clear method
-    def protect(message_key)
-      not_implemented
-    end
-
-    def delete(message_key)
-      not_implemented
-    end
-
-    # Clear the protected mark for a message.
-    def unprotect(message_key)
-      not_implemented
-    end
-
-    # Solve a particular message, causing all old messages with matching version and backtrace
-    # to be deleted (report should delete any solved messages when called)
-    def solve(message_key)
-      not_implemented
-    end
-
-    # Registers a rate limit on the given severities of logs
-    def register_rate_limit(severities, limit, duration, &block)
-      not_implemented
-    end
-
-    # Checks all the existing rate limiters to check if any has been exceeded
-    def check_rate_limits(severity)
-      not_implemented
-    end
-
-    def report(severity, progname, msg, opts = {})
-      return if (!msg || (String === msg && msg.empty?)) && skip_empty
-      return if level && severity < level
-
-      message = Logster::Message.new(severity, progname, msg, opts[:timestamp])
-
-      env = opts[:env] || {}
-      backtrace = opts[:backtrace]
-
-      if env[:backtrace]
-        # Special - passing backtrace through env
-        backtrace = env.delete(:backtrace)
-      end
-
-      message.populate_from_env(env)
-
-      if backtrace
-        if backtrace.respond_to? :join
-          backtrace = backtrace.join("\n")
-        end
-        message.backtrace = backtrace
-      else
-        message.backtrace = caller.join("\n")
-      end
-
-      return if ignore && ignore.any? { |pattern| message =~ pattern}
-
-      similar = nil
-
-      if Logster.config.allow_grouping
-        key = self.similar_key(message)
-        similar = get key if key
-      end
-
-      if similar
-        similar.count += 1
-        similar.merge_similar_message(message)
-
-        replace_and_bump similar
-        similar
-      else
-        save message
-        message
-      end
-    end
-
-    private
-
-    def not_implemented
-      raise "Not Implemented"
-    end
-  end
-end
+
+module Logster
+  class BaseStore
+
+    attr_accessor :level, :max_retention, :skip_empty, :ignore
+
+    def initialize
+      @max_retention = 60 * 60 * 24 * 7
+      @skip_empty = true
+    end
+
+    # Save a new message at the front of the latest list.
+    def save(message)
+      not_implemented
+    end
+
+    # Modify the saved message to the given one (identified by message.key) and bump it to the top of the latest list
+    def replace_and_bump(message)
+      not_implemented
+    end
+
+    # Check if another message with the same grouping_key is already stored.
+    # Returns the similar message's message.key
+    def similar_key(message)
+      not_implemented
+    end
+
+    # The number of messages currently stored.
+    def count
+      not_implemented
+    end
+
+    # Delete all unprotected messages in the store.
+    def clear
+      not_implemented
+    end
+
+    # Delete all messages, including protected messages.
+    def clear_all
+      not_implemented
+    end
+
+    # Get a message by its message_key
+    def get(message_key)
+      not_implemented
+    end
+
+    # Mark a message as protected; i.e. it is not deleted by the #clear method
+    def protect(message_key)
+      not_implemented
+    end
+
+    def delete(message_key)
+      not_implemented
+    end
+
+    # Clear the protected mark for a message.
+    def unprotect(message_key)
+      not_implemented
+    end
+
+    # Solve a particular message, causing all old messages with matching version and backtrace
+    # to be deleted (report should delete any solved messages when called)
+    def solve(message_key)
+      not_implemented
+    end
+
+    # Registers a rate limit on the given severities of logs
+    def register_rate_limit(severities, limit, duration, &block)
+      not_implemented
+    end
+
+    # Checks all the existing rate limiters to check if any has been exceeded
+    def check_rate_limits(severity)
+      not_implemented
+    end
+
+    def report(severity, progname, msg, opts = {})
+      return if (!msg || (String === msg && msg.empty?)) && skip_empty
+      return if level && severity < level
+
+      message = Logster::Message.new(severity, progname, msg, opts[:timestamp])
+
+      env = opts[:env] || {}
+      backtrace = opts[:backtrace]
+
+      if env[:backtrace]
+        # Special - passing backtrace through env
+        backtrace = env.delete(:backtrace)
+      end
+
+      message.populate_from_env(env)
+
+      if backtrace
+        if backtrace.respond_to? :join
+          backtrace = backtrace.join("\n")
+        end
+        message.backtrace = backtrace
+      else
+        message.backtrace = caller.join("\n")
+      end
+
+      return if ignore && ignore.any? { |pattern| message =~ pattern}
+
+      similar = nil
+
+      if Logster.config.allow_grouping
+        key = self.similar_key(message)
+        similar = get key if key
+      end
+
+      if similar
+        similar.count += 1
+        similar.merge_similar_message(message)
+
+        replace_and_bump similar
+        similar
+      else
+        save message
+        message
+      end
+    end
+
+    private
+
+    def not_implemented
+      raise "Not Implemented"
+    end
+  end
+end

data/lib/logster/configuration.rb

@@ -1,25 +1,25 @@
-module Logster
-  class Configuration
-    attr_accessor :current_context, :allow_grouping, :environments,
-      :application_version, :web_title
-
-    attr_writer :subdirectory
-
-    def initialize
-      # lambda |env,block|
-      @current_context = lambda{ |_, &block| block.call }
-      @environments = [:development, :production]
-      @subdirectory = nil
-
-      @allow_grouping = false
-
-      if defined?(::Rails) && defined?(::Rails.env) && ::Rails.env.production?
-        @allow_grouping = true
-      end
-    end
-
-    def subdirectory
-      @subdirectory || '/logs'
-    end
-  end
-end
+module Logster
+  class Configuration
+    attr_accessor :current_context, :allow_grouping, :environments,
+      :application_version, :web_title
+
+    attr_writer :subdirectory
+
+    def initialize
+      # lambda |env,block|
+      @current_context = lambda{ |_, &block| block.call }
+      @environments = [:development, :production]
+      @subdirectory = nil
+
+      @allow_grouping = false
+
+      if defined?(::Rails) && defined?(::Rails.env) && ::Rails.env.production?
+        @allow_grouping = true
+      end
+    end
+
+    def subdirectory
+      @subdirectory || '/logs'
+    end
+  end
+end

data/lib/logster/ignore_pattern.rb

@@ -1,65 +1,65 @@
-module Logster
-  class IgnorePattern
-
-    def initialize(message_pattern=nil, env_patterns=nil)
-      @msg_match = message_pattern
-      @env_match = env_patterns
-    end
-
-    def self.from_message_and_request_uri(msg, request)
-      IgnorePattern.new(msg, {REQUEST_URI: request})
-    end
-
-    def matches?(message)
-      if @msg_match
-        return false unless compare(message.message, @msg_match)
-      end
-
-      if @env_match
-        return false unless compare(message.env, @env_match)
-      end
-
-      true
-    end
-
-    def to_s
-      "<#Logster::IgnorePattern, msg_match: #{@msg_match.inspect}, env_match: #{@env_match.inspect}>"
-    end
-
-    private
-
-    def compare(message, pattern)
-      return false unless message && pattern
-
-      case pattern
-        when Regexp
-          message.to_s =~ pattern
-        when String
-          message.to_s.downcase =~ Regexp.new(pattern.downcase, Regexp::IGNORECASE)
-        when Hash
-          if Hash === message
-            compare_hash(message, pattern)
-          else
-            false
-          end
-        else
-          false
-      end
-    end
-
-    def compare_hash(message_hash, pattern_hash)
-      return false unless message_hash
-      pattern_hash.each do |key, value|
-        return false unless compare(get_indifferent(message_hash, key), value)
-      end
-      true
-    end
-
-    def get_indifferent(hash, key)
-      return hash[key] if hash[key]
-      return hash[key.to_s] if hash[key.to_s]
-      # no key.to_sym please, memory leak in Ruby < 2.2
-      nil
-    end
-  end
-end
+module Logster
+  class IgnorePattern
+
+    def initialize(message_pattern=nil, env_patterns=nil)
+      @msg_match = message_pattern
+      @env_match = env_patterns
+    end
+
+    def self.from_message_and_request_uri(msg, request)
+      IgnorePattern.new(msg, {REQUEST_URI: request})
+    end
+
+    def matches?(message)
+      if @msg_match
+        return false unless compare(message.message, @msg_match)
+      end
+
+      if @env_match
+        return false unless compare(message.env, @env_match)
+      end
+
+      true
+    end
+
+    def to_s
+      "<#Logster::IgnorePattern, msg_match: #{@msg_match.inspect}, env_match: #{@env_match.inspect}>"
+    end
+
+    private
+
+    def compare(message, pattern)
+      return false unless message && pattern
+
+      case pattern
+        when Regexp
+          message.to_s =~ pattern
+        when String
+          message.to_s.downcase =~ Regexp.new(pattern.downcase, Regexp::IGNORECASE)
+        when Hash
+          if Hash === message
+            compare_hash(message, pattern)
+          else
+            false
+          end
+        else
+          false
+      end
+    end
+
+    def compare_hash(message_hash, pattern_hash)
+      return false unless message_hash
+      pattern_hash.each do |key, value|
+        return false unless compare(get_indifferent(message_hash, key), value)
+      end
+      true
+    end
+
+    def get_indifferent(hash, key)
+      return hash[key] if hash[key]
+      return hash[key.to_s] if hash[key.to_s]
+      # no key.to_sym please, memory leak in Ruby < 2.2
+      nil
+    end
+  end
+end

data/lib/logster/logger.rb

@@ -1,102 +1,108 @@
-require 'logger'
-
-module Logster
-  class Logger < ::Logger
-    LOGSTER_ENV = "logster_env".freeze
-
-    attr_accessor :store, :skip_store
-    attr_reader :chained
-
-    def initialize(store)
-      super(nil)
-      @store = store
-      @override_levels = nil
-      @chained = []
-      @skip_store = false
-    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
-    end
-
-    def chain(logger)
-      @chained << logger
-    end
-
-    def add_to_chained(logger, severity, message, progname, opts=nil, &block)
-      if logger.respond_to? :skip_store
-        old = logger.skip_store
-        logger.skip_store = @skip_store
-      end
-
-      if logger.is_a?(self.class)
-        logger.add(severity, message, progname, opts, &block)
-      else
-        logger.add(severity, message, progname, &block)
-      end
-    ensure
-      if logger.respond_to? :skip_store
-        logger.skip_store = old
-      end
-    end
-
-    def add(*args, &block)
-      add_with_opts(*args,&block)
-    end
-
-    def level
-      ol = @override_levels
-      (ol && ol[Thread.current.object_id]) || @level
-    end
-
-    def add_with_opts(severity, message, progname, opts=nil, &block)
-      if severity < level
-        return true
-      end
-
-      if @chained
-        i = 0
-        # micro optimise for logging
-        while i < @chained.length
-          # TODO double yielding blocks
-          begin
-            add_to_chained(@chained[i], severity, message, progname, opts, &block)
-          rescue => e
-            # don't blow up if STDERR is somehow closed
-            STDERR.puts "Failed to report message to chained logger #{e}" rescue nil
-          end
-          i += 1
-        end
-      end
-
-      progname ||= @progname
-      if message.nil?
-        if block_given?
-          message = yield
-        else
-          message = progname
-          progname = @progname
-        end
-      end
-
-      return if @skip_store
-
-      opts ||= {}
-      opts[:env] ||= Thread.current[LOGSTER_ENV]
-
-      @store.report(severity, progname, message, opts)
-
-    rescue => e
-      # don't blow up if STDERR is somehow closed
-      STDERR.puts "Failed to report error: #{e} #{severity} #{message} #{progname}" rescue nil
-    end
-  end
-end
+require 'logger'
+
+module Logster
+  class Logger < ::Logger
+    LOGSTER_ENV = "logster_env".freeze
+
+    attr_accessor :store, :skip_store
+    attr_reader :chained
+
+    def initialize(store)
+      super(nil)
+      @store = store
+      @override_levels = nil
+      @chained = []
+      @skip_store = false
+    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
+    end
+
+    def chain(logger)
+      @chained << logger
+    end
+
+    def add_to_chained(logger, severity, message, progname, opts=nil, &block)
+      if logger.respond_to? :skip_store
+        old = logger.skip_store
+        logger.skip_store = @skip_store
+      end
+
+      if logger.is_a?(self.class)
+        logger.add(severity, message, progname, opts, &block)
+      else
+        logger.add(severity, message, progname, &block)
+      end
+    ensure
+      if logger.respond_to? :skip_store
+        logger.skip_store = old
+      end
+    end
+
+    def add(*args, &block)
+      add_with_opts(*args,&block)
+    end
+
+    def level
+      ol = @override_levels
+      (ol && ol[Thread.current.object_id]) || @level
+    end
+
+    def add_with_opts(severity, message, progname, opts=nil, &block)
+      if severity < level
+        return true
+      end
+
+      # it is not fun losing messages cause encoding is bad
+      # protect all messages by scrubbing if needed
+      if message && !message.valid_encoding?
+        message = message.scrub
+      end
+
+      if @chained
+        i = 0
+        # micro optimise for logging
+        while i < @chained.length
+          # TODO double yielding blocks
+          begin
+            add_to_chained(@chained[i], severity, message, progname, opts, &block)
+          rescue => e
+            # don't blow up if STDERR is somehow closed
+            STDERR.puts "Failed to report message to chained logger #{e}" rescue nil
+          end
+          i += 1
+        end
+      end
+
+      progname ||= @progname
+      if message.nil?
+        if block_given?
+          message = yield
+        else
+          message = progname
+          progname = @progname
+        end
+      end
+
+      return if @skip_store
+
+      opts ||= {}
+      opts[:env] ||= Thread.current[LOGSTER_ENV]
+
+      @store.report(severity, progname, message, opts)
+
+    rescue => e
+      # don't blow up if STDERR is somehow closed
+      STDERR.puts "Failed to report error: #{e} #{severity} #{message} #{progname}" rescue nil
+    end
+  end
+end