betterlog 0.1.0 → 0.2.0

data/lib/betterlog/log.rb

@@ -4,178 +4,195 @@ require 'betterlog/log/event'
 require 'betterlog/log/event_formatter'
 require 'betterlog/log/severity'
 
-class Log
-  include Tins::SexySingleton
+module Betterlog
+  class Log
+    include Tins::SexySingleton
 
-  def logger
-    Rails.logger
-  end
+    class_attr_accessor :default_logger
+    self.default_logger = Logger.new(STDERR)
 
-  # Logs a message on severity info.
-  #
-  # @param object this object is logged
-  # @param **rest additional data is logged as well.
-  # @return [ Log ] this object itself.
-  def info(object, **rest)
-    protect do
-      emit Log::Event.ify(object, severity: __method__, rest: rest)
+    def logger
+      defined?(Rails) && Rails.logger || self.class.default_logger
     end
-  end
 
-  # Logs a message on severity warn.
-  #
-  # @param object this object is logged
-  # @param **rest additional data is logged as well.
-  # @return [ Log ] this object itself.
-  def warn(object, **rest)
-    protect do
-      emit Log::Event.ify(object, severity: __method__, rest: rest)
+    # Logs a message on severity info.
+    #
+    # @param object this object is logged
+    # @param **rest additional data is logged as well.
+    # @return [ Log ] this object itself.
+    def info(object, **rest)
+      protect do
+        emit Log::Event.ify(object, severity: __method__, rest: rest)
+      end
     end
-  end
 
-  # Logs a message on severity debug.
-  #
-  # @param object this object is logged
-  # @param **rest additional data is logged as well.
-  # @return [ Log ] this object itself.
-  def debug(object, **rest)
-    protect do
-      emit Log::Event.ify(object, severity: __method__, rest: rest)
+    # Logs a message on severity warn.
+    #
+    # @param object this object is logged
+    # @param **rest additional data is logged as well.
+    # @return [ Log ] this object itself.
+    def warn(object, **rest)
+      protect do
+        emit Log::Event.ify(object, severity: __method__, rest: rest)
+      end
     end
-  end
 
-  # Logs a message on severity error.
-  #
-  # @param object this object is logged
-  # @param **rest additional data is logged as well.
-  # @return [ Log ] this object itself.
-  def error(object, **rest)
-    protect do
-      emit Log::Event.ify(object, severity: __method__, rest: rest)
+    # Logs a message on severity debug.
+    #
+    # @param object this object is logged
+    # @param **rest additional data is logged as well.
+    # @return [ Log ] this object itself.
+    def debug(object, **rest)
+      protect do
+        emit Log::Event.ify(object, severity: __method__, rest: rest)
+      end
     end
-  end
 
-  # Logs a message on severity fatal.
-  #
-  # @param object this object is logged
-  # @param **rest additional data is logged as well.
-  # @return [ Log ] this object itself.
-  def fatal(object, **rest)
-    protect do
-      emit Log::Event.ify(object, severity: __method__, rest: rest)
+    # Logs a message on severity error.
+    #
+    # @param object this object is logged
+    # @param **rest additional data is logged as well.
+    # @return [ Log ] this object itself.
+    def error(object, **rest)
+      protect do
+        emit Log::Event.ify(object, severity: __method__, rest: rest)
+      end
     end
-  end
 
-  # Logs a message on severity debug, by default, this can be changed by
-  # passing the severity: keyword.
-  #
-  # @param object this object is logged
-  # @param **rest additional data is logged as well.
-  # @return [ Log ] this object itself.
-  def output(object, **rest)
-    protect do
-      emit Log::Event.ify(object, severity: rest[:severity], rest: rest)
+    # Logs a message on severity fatal.
+    #
+    # @param object this object is logged
+    # @param **rest additional data is logged as well.
+    # @return [ Log ] this object itself.
+    def fatal(object, **rest)
+      protect do
+        emit Log::Event.ify(object, severity: __method__, rest: rest)
+      end
     end
-  end
 
-  # Logs a metric on severity debug, by default, this can be changed by passing
-  # the severity: keyword.
-  #
-  # @param metric the name of the recorded metric.
-  # @param type of the recorded metric.
-  # @param value of the recorded metric.
-  # @param **rest additional rest is logged as well.
-  # @return [ Log ] this object itself.
-  def metric(metric:, type:, value:, **rest)
-    protect do
-      event = build_metric(metric: metric, type: type, value: value, **rest)
-      emit event
+    # Logs a message on severity debug, by default, this can be changed by
+    # passing the severity: keyword.
+    #
+    # @param object this object is logged
+    # @param **rest additional data is logged as well.
+    # @return [ Log ] this object itself.
+    def output(object, **rest)
+      protect do
+        emit Log::Event.ify(object, severity: rest[:severity], rest: rest)
+      end
     end
-  end
 
-  # Logs a time measure on severity debug, by default, this can be changed by
-  # passing the severity: keyword.
-  #
-  # If an error occurs during measurement details about it are added to the
-  # metric event.
-  #
-  # @param metric the name of the recorded metric.
-  # @param **rest additional rest is logged as well.
-  # @param block the block around which the measure is teaken.
-  # @return [ Log ] this object itself.
-  def measure(metric:, **rest, &block)
-    raise ArgumentError, 'must be called with a block' unless block_given?
-    time_block { yield }
-  rescue => error
-    e = Log::Event.ify(error)
-    rest |= e.as_hash.subhash(:error_class, :backtrace, :message)
-    rest[:message] = "#{rest[:message]} while measuring metric #{metric}"
-    raise error
-  ensure
-    protect do
-      event = build_metric(metric: metric, type: 'seconds', value: timed_duration, **rest)
-      emit event
+    # Logs a metric on severity debug, by default, this can be changed by passing
+    # the severity: keyword.
+    #
+    # @param metric the name of the recorded metric.
+    # @param type of the recorded metric.
+    # @param value of the recorded metric.
+    # @param **rest additional rest is logged as well.
+    # @return [ Log ] this object itself.
+    def metric(metric:, type:, value:, **rest)
+      protect do
+        event = build_metric(metric: metric, type: type, value: value, **rest)
+        emit event
+      end
     end
-  end
 
-  private
-
-  def protect
-    yield
-  rescue => e
-    begin
-      # Try logging e once by ourselves
-      emit Log::Event.ify(e, severity: :fatal)
-    rescue
-      # Ok, I give up let's use logger directly instead
-      logger.fatal(
-        "Crashed during logging with #{e.class}: #{e.message}):\n"\
-        "#{e.backtrace * ?\n}"
-      )
+    # Logs a time measure on severity debug, by default, this can be changed by
+    # passing the severity: keyword.
+    #
+    # If an error occurs during measurement details about it are added to the
+    # metric event.
+    #
+    # @param metric the name of the recorded metric.
+    # @param **rest additional rest is logged as well.
+    # @param block the block around which the measure is teaken.
+    # @return [ Log ] this object itself.
+    def measure(metric:, **rest, &block)
+      raise ArgumentError, 'must be called with a block' unless block_given?
+      time_block { yield }
+    rescue => error
+      e = Log::Event.ify(error)
+      rest |= e.as_hash.subhash(:error_class, :backtrace, :message)
+      rest[:message] = "#{rest[:message]} while measuring metric #{metric}"
+      raise error
+    ensure
+      protect do
+        event = build_metric(metric: metric, type: 'seconds', value: timed_duration, **rest)
+        emit event
+      end
     end
-    self
-  end
 
-  def build_metric(metric:, type:, value:, **rest)
-    severity = rest.fetch(:severity, :debug)
-    rest |= {
-      message: "a metric #{metric} of type #{type}",
-    }
-    Log::Event.ify(
-      {
-        metric: metric,
-        type: type,
-        value: value,
-      } | rest,
-      severity: severity
-    )
-  end
+    def context(data_hash)
+      GlobalMetadata.add data_hash
+      self
+    end
+
+    def self.context(data_hash)
+      instance.context(data_hash)
+    end
 
-  def emit(event)
-    if l = caller_locations.reverse_each.each_cons(3).find { |c, n1, n2|
-      n2.absolute_path =~ /app\/lib\/log\.rb/ and break c
-    }
-      then
-      event[:location] = [ l.absolute_path, l.lineno ] * ?:
+    private
+
+    def protect
+      yield
+    rescue => e
+      begin
+        # Try logging e once by ourselves
+        emit Log::Event.ify(e, severity: :fatal)
+      rescue
+        # Ok, I give up let's use logger directly instead
+        logger.fatal(
+          "Crashed during logging with #{e.class}: #{e.message}):\n"\
+          "#{e.backtrace * ?\n}"
+        )
+      end
+      self
+    end
+
+    def build_metric(metric:, type:, value:, **rest)
+      severity = rest.fetch(:severity, :debug)
+      rest |= {
+        message: "a metric #{metric} of type #{type}",
+      }
+      Log::Event.ify(
+        {
+          metric: metric,
+          type: type,
+          value: value,
+        } | rest,
+        severity: severity
+      )
     end
-    event[:emitter] = self.class.name.downcase
-    if event.notify?
+
+    def emit(event)
+      l = caller_locations.reverse_each.each_cons(3).find { |c, n1, n2|
+        n2.absolute_path =~ /betterlog\/log\.rb/ and break c # TODO check if this still works
+      }
+      if l
+        event[:location] = [ l.absolute_path, l.lineno ] * ?:
+      end
+      event[:emitter] = self.class.name.downcase
       notify(event)
+      logger.send(event.severity.to_sym, event.to_json)
+      self
+    ensure
+      GlobalMetadata.data.clear
     end
-    logger.send(event.severity.to_sym, event.to_json)
-    self
-  end
 
-  def notify(event)
-    Honeybadger.notify(event.notify?, event.as_hash)
-  end
+    def notify(event)
+      if event.notify?
+        Notifiers.notify(event)
+        self
+      end
+    end
 
-  thread_local :timed_duration
+    thread_local :timed_duration
 
-  def time_block
-    s = Time.now
-    yield
-  ensure
-    self.timed_duration = Time.now - s
+    def time_block
+      s = Time.now
+      yield
+    ensure
+      self.timed_duration = Time.now - s
+    end
   end
 end

data/lib/betterlog/log_event_formatter.rb

@@ -1,47 +1,49 @@
-class LogEventFormatter < ActiveSupport::Logger::Formatter
-  include ActiveSupport::TaggedLogging::Formatter
+module Betterlog
+  class LogEventFormatter < ActiveSupport::Logger::Formatter
+    include ActiveSupport::TaggedLogging::Formatter
 
-  def emitter
-    'legacy'
-  end
+    def emitter
+      'legacy'
+    end
 
-  def call(severity, timestamp, program, message)
-    super
-    message = message.to_s
-    if cc.log.legacy_supported
-      if message.blank?
-        return ''
-      elsif !Log::Event.is?(message)
-        m = message.sub(/\s+$/, '')
-        timestamp = timestamp.utc.iso8601(3)
-        event = Log::Event.new(
-          emitter:    emitter,
-          timestamp:  timestamp,
-          message:    m,
-          severity:   severity.to_s.downcase,
-          # tags:       current_tags,
-        )
-        if backtrace = m.grep(/^\s*([^:]+):(\d+)/)
-          if backtrace.size > 1
-            event[:backtrace] = backtrace.map(&:chomp)
-            event[:message] = 'a logged backtrace'
+    def call(severity, timestamp, program, message)
+      super
+      message = message.to_s
+      if cc.log.legacy_supported
+        if message.blank?
+          return ''
+        elsif !Log::Event.is?(message)
+          m = message.sub(/\s+$/, '')
+          timestamp = timestamp.utc.iso8601(3)
+          event = Log::Event.new(
+            emitter:    emitter,
+            timestamp:  timestamp,
+            message:    m,
+            severity:   severity.to_s.downcase,
+            # tags:       current_tags,
+          )
+          if backtrace = m.grep(/^\s*([^:]+):(\d+)/)
+            if backtrace.size > 1
+              event[:backtrace] = backtrace.map(&:chomp)
+              event[:message] = 'a logged backtrace'
+            end
           end
+          if l = caller_locations.reverse_each.each_cons(2).find { |c, n|
+               n.absolute_path =~ /\/lib\/ruby\/.*?\/logger\.rb/ and break c
+            }
+          then
+            event[:location] = [ l.absolute_path, l.lineno ] * ?:
+          end
+          program and event[:program] = program
+          message = event.to_json
         end
-        if l = caller_locations.reverse_each.each_cons(2).find { |c, n|
-             n.absolute_path =~ /\/lib\/ruby\/.*?\/logger\.rb/ and break c
-          }
-        then
-          event[:location] = [ l.absolute_path, l.lineno ] * ?:
-        end
-        program and event[:program] = program
-        message = event.to_json
       end
+    rescue => e
+      Betterlog::Log.logger.error(e)
+    ensure
+      # Do not "message << ?\n" - A frozn string may be passed in
+      message.end_with?(?\n) or message = "#{message}\n"
+      return message
     end
-  rescue => e
-    Rails.logger.error(e)
-  ensure
-    # Do not "message << ?\n" - A frozn string may be passed in
-    message.end_with?(?\n) or message = "#{message}\n"
-    return message
   end
 end

data/lib/betterlog/logger.rb

@@ -0,0 +1,88 @@
+require 'redis'
+
+module Betterlog
+  class Logger < ::Logger
+    def initialize(redis, shift_age = 0, shift_size = 1048576, name: nil, **opts)
+      @redis = redis
+      @name  = name || self.class.name
+      super(@logdev, shift_age, shift_size, **opts)
+    end
+
+    private def redis_write(msg)
+      # Redis string limit is at 512MB, stop before that after warning a lot.
+      if @redis.strlen(@name) > 511 * 1024 ** 2
+        return nil
+      end
+      if @redis.strlen(@name) > 510 * 1024 ** 2
+        @redis.append @name, "\nRedis memory limit will soon be reached =>"\
+          " Log output to redis stops now unless log data is pushed away!\n"
+        return nil
+      end
+      @redis.append @name, msg
+      self
+    end
+
+
+    def add(severity, message = nil, progname = nil)
+      severity ||= UNKNOWN
+      if severity < @level
+        return true
+      end
+      if progname.nil?
+        progname = @progname
+      end
+      if message.nil?
+        if block_given?
+          message = yield
+        else
+          message = progname
+          progname = @progname
+        end
+      end
+      redis_write(
+        format_message(format_severity(severity), Time.now, progname, message))
+      true
+    end
+
+    def <<(msg)
+      redis_write(msg)
+    end
+
+    def clear
+      @redis.del @name
+      self
+    end
+
+    def each_chunk(chunk_size: 100 * 1024, &block)
+      chunk_size > 0 or raise ArgumentError, 'chunk_size > 0 required'
+      @redis.exists(@name) or return Enumerator.new {}
+      Enumerator.new do |y|
+        name_tmp = "#{@name}_#{rand}"
+        @redis.rename @name, name_tmp
+        s = 0
+        e = @redis.strlen(name_tmp) - 1
+        until s > e
+          y.yield @redis.getrange(name_tmp, s, s + chunk_size - 1)
+          s += chunk_size
+        end
+        @redis.del name_tmp
+      end.each(&block)
+    end
+
+    def each(chunk_size: 100 * 1024, &block)
+      chunk_size > 0 or raise ArgumentError, 'chunk_size > 0 required'
+      Enumerator.new do |y|
+        buffer = ''
+        each_chunk(chunk_size: chunk_size) do |chunk|
+          buffer << chunk
+          buffer.gsub!(/\A(.*?#$/)/) do |line|
+            y.yield(line)
+            ''
+          end
+        end
+        buffer.length > 0 and y.yield(buffer)
+      end.each(&block)
+    end
+    include Enumerable
+  end
+end

data/lib/betterlog/notifiers.rb

@@ -0,0 +1,28 @@
+module Betterlog
+  module Notifiers
+
+    class_attr_accessor :notifiers
+
+    self.notifiers = Set[]
+
+    def self.register(notifier)
+      notifier.respond_to?(:notify) or raise TypeError,
+        "notifier has to respond to notify(message, hash) interface"
+      notifiers << notifier
+      self
+    end
+
+    def self.notify(event)
+      notifiers.each do |notifier|
+        notifier.notify(event.notify?, event.as_hash)
+      end
+    end
+
+    def self.context(data_hash)
+      notifiers.each do |notifier|
+        notifier.respond_to?(:context) or next
+        notifier.context(data_hash)
+      end
+    end
+  end
+end

data/lib/betterlog/railtie.rb

@@ -0,0 +1,8 @@
+module Betterlog
+  class Railtie < Rails::Railtie
+    initializer "betterlog_railtie.configure_rails_initialization" do
+      Rails.logger = Betterlog::Logger.new(Redis.new) # TODO
+      Rails.logger.formatter = Betterlog::LogEventFormatter.new
+    end
+  end
+end

data/lib/betterlog/version.rb

@@ -1,6 +1,6 @@
 module Betterlog
   # Betterlog version
-  VERSION         = '0.1.0'
+  VERSION         = '0.2.0'
   VERSION_ARRAY   = VERSION.split('.').map(&:to_i) # :nodoc:
   VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
   VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:

data/lib/betterlog.rb

@@ -2,13 +2,19 @@ require 'tins/xt'
 require 'json'
 require 'logger'
 require 'time'
-require 'tins'
-require 'rails'
-
-require 'active_support'
 require 'term/ansicolor'
 
-require 'betterlog/global_metadata'
-require 'betterlog/betterlog_railtie'
+module Betterlog
+end
+
 require 'betterlog/log'
-require 'betterlog/log_event_formatter'
+require 'betterlog/notifiers'
+require 'betterlog/global_metadata'
+require 'betterlog/logger'
+
+if defined? Rails
+  require 'betterlog/log_event_formatter'
+  require 'betterlog/railtie'
+end
+
+Log = Betterlog::Log

data/spec/betterlog/global_metadata_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Betterlog::GlobalMetadata do
+  let :notifier do
+    Class.new do
+      def notify(message, hash) end
+
+      def context(data_hash) end
+    end.new
+  end
+
+  around do |example|
+    Betterlog::Notifiers.register(notifier)
+    example.run
+  ensure
+    Betterlog::Notifiers.notifiers.clear
+    described_class.data.clear
+  end
+
+  it 'can haz empty data' do
+    expect(described_class.data).to eq({})
+  end
+
+  it 'can haz some data' do
+    described_class.data |= { foo: 'bar' }
+    expect(described_class.data).to eq({ foo: 'bar' })
+  end
+
+  it 'can "add" data' do
+    expect(notifier).to receive(:context).with(foo: 'bar')
+    expect(described_class.add(foo: 'bar')).to eq described_class.instance
+  end
+
+  it 'can "add" data via Log.context' do
+    expect(notifier).to receive(:context).with(foo: 'bar')
+    Betterlog::Log.context(foo: 'bar')
+  end
+end