logster 2.1.0 → 2.1.1

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/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?(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

data/lib/logster/message.rb

@@ -1,212 +1,212 @@
-require 'digest/sha1'
-require 'securerandom'
-
-module Logster
-
-  MAX_GROUPING_LENGTH = 50
-
-  class Message
-    LOGSTER_ENV = "_logster_env".freeze
-    ALLOWED_ENV = %w{
-      HTTP_HOST
-      REQUEST_URI
-      REQUEST_METHOD
-      HTTP_USER_AGENT
-      HTTP_ACCEPT
-      HTTP_REFERER
-      HTTP_X_FORWARDED_FOR
-      HTTP_X_REAL_IP
-      hostname
-      process_id
-      application_version
-    }
-
-    attr_accessor :timestamp, :severity, :progname, :message, :key, :backtrace, :count, :env, :protected, :first_timestamp
-
-    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 = count || 1
-      @protected = false
-      @first_timestamp = nil
-    end
-
-    def to_h(exclude_env: false)
-      h = {
-        message: @message,
-        progname: @progname,
-        severity: @severity,
-        timestamp: @timestamp,
-        key: @key,
-        backtrace: @backtrace,
-        count: @count,
-        protected: @protected
-      }
-
-      h[:first_timestamp] = @first_timestamp if @first_timestamp
-      h[:env] = @env unless exclude_env
-
-      h
-    end
-
-    def to_json(opts = nil)
-      exclude_env = Hash === opts && opts.delete(:exclude_env)
-      JSON.fast_generate(to_h(exclude_env: exclude_env), opts)
-    end
-
-    def self.from_json(json)
-      parsed = ::JSON.parse(json)
-      msg = new(parsed["severity"],
-            parsed["progname"],
-            parsed["message"],
-            parsed["timestamp"],
-            parsed["key"])
-      msg.backtrace = parsed["backtrace"]
-      msg.env = parsed["env"]
-      msg.count = parsed["count"]
-      msg.protected = parsed["protected"]
-      msg.first_timestamp = parsed["first_timestamp"]
-      msg
-    end
-
-    def self.hostname
-      @hostname ||= `hostname`.strip! rescue "<unknown>"
-    end
-
-    def populate_from_env(env)
-      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
-      env = {
-        "hostname" => hostname,
-        "process_id" => Process.pid
-      }
-      env["application_version"] = Logster.config.application_version if Logster.config.application_version
-      env
-    end
-
-    # in its own method so it can be overridden
-    def grouping_hash
-      return { message: self.message, severity: self.severity, backtrace: self.backtrace }
-    end
-
-    # todo - memoize?
-    def grouping_key
-      Digest::SHA1.hexdigest JSON.fast_generate grouping_hash
-    end
-
-    # todo - memoize?
-    def solved_keys
-      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|
-          Digest::SHA1.hexdigest "#{version} #{backtrace}"
-        end
-      end
-    end
-
-    def is_similar?(other)
-      self.grouping_key == other.grouping_key
-    end
-
-    def merge_similar_message(other)
-      self.first_timestamp ||= self.timestamp
-      self.timestamp = [self.timestamp, other.timestamp].max
-
-      self.count += other.count || 1
-      return false if self.count > Logster::MAX_GROUPING_LENGTH
-
-      other_env = JSON.load JSON.fast_generate other.env
-      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
-      true
-    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
-        end
-        scrubbed["params"] = params if params.length > 0
-        ALLOWED_ENV.map { |k|
-          scrubbed[k] = env[k] if env[k]
-        }
-        scrubbed
-      end
-    end
-
-    def <=>(other)
-      time = self.timestamp <=> other.timestamp
-      return time if time && time != 0
-
-      self.key <=> other.key
-    end
-
-    def =~(pattern)
-      case pattern
-      when Hash
-        IgnorePattern.new(nil, pattern).matches? self
-      when String
-        IgnorePattern.new(pattern, nil).matches? self
-      when Regexp
-        IgnorePattern.new(pattern, nil).matches? self
-      when IgnorePattern
-        pattern.matches? self
-        else
-        nil
-      end
-    end
-
-    protected
-
-    def get_timestamp
-      (Time.new.to_f * 1000).to_i
-    end
-  end
-end
+require 'digest/sha1'
+require 'securerandom'
+
+module Logster
+
+  MAX_GROUPING_LENGTH = 50
+
+  class Message
+    LOGSTER_ENV = "_logster_env".freeze
+    ALLOWED_ENV = %w{
+      HTTP_HOST
+      REQUEST_URI
+      REQUEST_METHOD
+      HTTP_USER_AGENT
+      HTTP_ACCEPT
+      HTTP_REFERER
+      HTTP_X_FORWARDED_FOR
+      HTTP_X_REAL_IP
+      hostname
+      process_id
+      application_version
+    }
+
+    attr_accessor :timestamp, :severity, :progname, :message, :key, :backtrace, :count, :env, :protected, :first_timestamp
+
+    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 = count || 1
+      @protected = false
+      @first_timestamp = nil
+    end
+
+    def to_h(exclude_env: false)
+      h = {
+        message: @message,
+        progname: @progname,
+        severity: @severity,
+        timestamp: @timestamp,
+        key: @key,
+        backtrace: @backtrace,
+        count: @count,
+        protected: @protected
+      }
+
+      h[:first_timestamp] = @first_timestamp if @first_timestamp
+      h[:env] = @env unless exclude_env
+
+      h
+    end
+
+    def to_json(opts = nil)
+      exclude_env = Hash === opts && opts.delete(:exclude_env)
+      JSON.fast_generate(to_h(exclude_env: exclude_env), opts)
+    end
+
+    def self.from_json(json)
+      parsed = ::JSON.parse(json)
+      msg = new(parsed["severity"],
+            parsed["progname"],
+            parsed["message"],
+            parsed["timestamp"],
+            parsed["key"])
+      msg.backtrace = parsed["backtrace"]
+      msg.env = parsed["env"]
+      msg.count = parsed["count"]
+      msg.protected = parsed["protected"]
+      msg.first_timestamp = parsed["first_timestamp"]
+      msg
+    end
+
+    def self.hostname
+      @hostname ||= `hostname`.strip! rescue "<unknown>"
+    end
+
+    def populate_from_env(env)
+      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
+      env = {
+        "hostname" => hostname,
+        "process_id" => Process.pid
+      }
+      env["application_version"] = Logster.config.application_version if Logster.config.application_version
+      env
+    end
+
+    # in its own method so it can be overridden
+    def grouping_hash
+      return { message: self.message, severity: self.severity, backtrace: self.backtrace }
+    end
+
+    # todo - memoize?
+    def grouping_key
+      Digest::SHA1.hexdigest JSON.fast_generate grouping_hash
+    end
+
+    # todo - memoize?
+    def solved_keys
+      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|
+          Digest::SHA1.hexdigest "#{version} #{backtrace}"
+        end
+      end
+    end
+
+    def is_similar?(other)
+      self.grouping_key == other.grouping_key
+    end
+
+    def merge_similar_message(other)
+      self.first_timestamp ||= self.timestamp
+      self.timestamp = [self.timestamp, other.timestamp].max
+
+      self.count += other.count || 1
+      return false if self.count > Logster::MAX_GROUPING_LENGTH
+
+      other_env = JSON.load JSON.fast_generate other.env
+      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
+      true
+    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
+        end
+        scrubbed["params"] = params if params.length > 0
+        ALLOWED_ENV.map { |k|
+          scrubbed[k] = env[k] if env[k]
+        }
+        scrubbed
+      end
+    end
+
+    def <=>(other)
+      time = self.timestamp <=> other.timestamp
+      return time if time && time != 0
+
+      self.key <=> other.key
+    end
+
+    def =~(pattern)
+      case pattern
+      when Hash
+        IgnorePattern.new(nil, pattern).matches? self
+      when String
+        IgnorePattern.new(pattern, nil).matches? self
+      when Regexp
+        IgnorePattern.new(pattern, nil).matches? self
+      when IgnorePattern
+        pattern.matches? self
+        else
+        nil
+      end
+    end
+
+    protected
+
+    def get_timestamp
+      (Time.new.to_f * 1000).to_i
+    end
+  end
+end