logster 2.1.2 → 2.2.0

data/lib/logster/cache.rb

@@ -0,0 +1,20 @@
+module Logster
+  class Cache
+    def initialize(age = 2)
+      @age = age
+      @hash = { created_at: Process.clock_gettime(Process::CLOCK_MONOTONIC) }
+    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)
+      end
+      @hash[:data]
+    end
+
+    def clear
+      @hash.delete(:data)
+    end
+  end
+end

data/lib/logster/configuration.rb

@@ -1,26 +1,27 @@
-module Logster
-  class Configuration
-    attr_accessor :current_context, :allow_grouping, :environments,
-      :application_version, :web_title, :env_expandable_keys
-
-    attr_writer :subdirectory
-
-    def initialize
-      # lambda |env,block|
-      @current_context = lambda { |_, &block| block.call }
-      @environments = [:development, :production]
-      @subdirectory = nil
-      @env_expandable_keys = []
-
-      @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, :env_expandable_keys, :enable_custom_patterns_via_ui
+
+    attr_writer :subdirectory
+
+    def initialize
+      # lambda |env,block|
+      @current_context = lambda { |_, &block| block.call }
+      @environments = [:development, :production]
+      @subdirectory = nil
+      @env_expandable_keys = []
+      @enable_custom_patterns_via_ui = false
+
+      @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/defer_logger.rb

@@ -1,14 +1,14 @@
-require 'logster/scheduler'
-
-module Logster
-  class DeferLogger < ::Logster::Logger
-    private
-
-    def report_to_store(severity, progname, message, opts = {})
-      opts[:backtrace] ||= caller
-      Logster::Scheduler.schedule do
-        super(severity, progname, message, opts)
-      end
-    end
-  end
-end
+require 'logster/scheduler'
+
+module Logster
+  class DeferLogger < ::Logster::Logger
+    private
+
+    def report_to_store(severity, progname, message, opts = {})
+      opts[:backtrace] ||= caller
+      Logster::Scheduler.schedule do
+        super(severity, progname, message, opts)
+      end
+    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 =~ Regexp.new(pattern, 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 =~ Regexp.new(pattern, 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,113 +1,113 @@
-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 = 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]
-
-      report_to_store(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
-
-    private
-
-    def report_to_store(severity, progname, message, opts = {})
-      @store.report(severity, progname, message, opts)
-    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?(Logster::Logger)
+        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 = 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]
+
+      report_to_store(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
+
+    private
+
+    def report_to_store(severity, progname, message, opts = {})
+      @store.report(severity, progname, message, opts)
+    end
+  end
+end