betterlog 0.1.0

data/lib/betterlog/log/event.rb

@@ -0,0 +1,163 @@
+class Log
+  class Event
+    require 'socket'
+
+    def self.ify(arg, severity: :debug, notify: nil, rest: {})
+      notify ||= rest.delete(:notify)
+      if e = arg.ask_and_send(:exception)
+        ify(
+          {
+            error_class:  e.class.name,
+            message:      "#{e.class.name}: #{e.message}",
+            backtrace:    e.backtrace,
+          },
+          severity: severity,
+          rest: rest,
+          notify: notify,
+        )
+      elsif s = arg.ask_and_send(:to_str)
+        new(
+          ({ notify: s } if notify).to_h |
+          {
+            message:  s,
+            severity: severity,
+          } | rest
+        )
+      elsif h = arg.ask_and_send(:to_hash)
+        arg = h | { severity: severity } | rest
+        new(
+          ({ notify: h[:message] || arg.to_s } if notify).to_h |
+          arg
+        )
+      else
+        message = "Logging #{arg.inspect}"
+        new(
+          ({ notify: message } if notify).to_h |
+          {
+            message: message,
+            severity: severity,
+          } | rest
+        )
+      end
+    end
+
+    def self.parse(json)
+      new(JSON.parse(json))
+    rescue JSON::ParserError
+    end
+
+    def self.is?(json)
+      if json = json.ask_and_send(:to_str)
+        data = JSON.parse(json).ask_and_send(:to_hash)
+        data&.key?('emitter')
+      end
+    rescue JSON::ParserError
+      false
+    end
+
+    def initialize(data = {})
+      data = data.symbolize_keys_recursive | meta
+      unless data.key?(:message)
+        data[:message] = "a #{data[:type]} type log message of severity #{data[:severity]}"
+      end
+      data[:severity] =
+        begin
+          Severity.new((data[:severity] || :debug))
+        rescue
+          Severity.new(:debug)
+        end
+      @data = Hash[data.sort_by(&:first)]
+    end
+
+    class BreakCircles
+      def initialize
+        @seen   = {}
+      end
+
+      IN_JSON = Tins::ModuleGroup[
+        Float, Integer, NilClass, FalseClass, TrueClass
+      ]
+
+      def perform(object)
+        if @seen.key?(object.__id__)
+          :circular
+        else
+          @seen[object.__id__] = true
+          case
+          when h = object.ask_and_send(:to_hash)
+            h.each_with_object({}) { |(k, v), h| h[k.to_s.to_sym] = perform(v) }
+          when a = object.ask_and_send(:to_ary)
+            a.map { |o| perform(o) }
+          when IN_JSON === object
+            object
+          else
+            object.to_s
+          end
+        end
+      end
+    end
+
+    def as_hash(*a)
+      BreakCircles.new.perform(@data)
+    end
+
+    def to_json(*a)
+      as_hash.to_json(*a)
+    end
+
+    def format(*args)
+      Log::EventFormatter.new(self).format(*args)
+    end
+
+    alias to_s format
+
+    def []=(name, value)
+      @data[name.to_sym] = value
+    end
+
+    def [](name)
+      @data[name.to_sym]
+    end
+
+    def severity
+      @data[:severity]
+    end
+
+    def emitter
+      @data[:emitter]
+    end
+
+    def notify?
+      @data[:notify]
+    end
+
+    def eql?(other)
+      @data.eql? other.instance_variable_get(:@data)
+    end
+
+    alias == eql?
+
+    def hash
+      @data.hash
+    end
+
+    private
+
+    def meta
+      m = {
+        timestamp: Time.now.utc.iso8601(3),
+        pid:       $$,
+        program:   File.basename($0),
+        severity:  :debug,
+        type:      'rails',
+        facility:  'local0',
+        host:      (Socket.gethostname rescue nil),
+        thread_id:  Thread.current.object_id
+      }
+      if defined? GlobalMetadata
+        m |= GlobalMetadata.data
+      end
+      m
+    end
+  end
+end

data/lib/betterlog/log/event_formatter.rb

@@ -0,0 +1,117 @@
+class Log
+  class EventFormatter
+    include Term::ANSIColor
+
+    def initialize(event)
+      @event = event
+    end
+
+    def format(pretty: false, color: false, format: :default)
+      old_coloring, Term::ANSIColor.coloring = Term::ANSIColor.coloring?, color
+      f = cc.log.formats[format] and format = f
+      case pretty
+      when :format
+        format_pattern(format: format)
+      else
+        @event.to_json
+      end
+    ensure
+      Term::ANSIColor.coloring = old_coloring
+    end
+
+    private
+
+    def colorize(key, value, string = key)
+      case style = cc.log.styles[key]
+      when nil, String, Array
+        apply_style(style, string)
+      when ComplexConfig::Settings
+        apply_style(style[value], string)
+      end
+    end
+
+    def apply_style(style, string)
+      style.nil? and return string + Term::ANSIColor.reset
+      string = Term::ANSIColor.uncolor(string)
+      if style.respond_to?(:each)
+        style.
+          each.
+          map { |s| -> v { __send__(:color, s, v) } }.
+          inject(string) { |v, s| s.(v) }
+      else
+        __send__(:color, style, string)
+      end
+    end
+
+    def format_pattern(format:)
+      format.
+        gsub('\n', "\n").
+        gsub('\t', "\t").
+        gsub(/\{(-)?(%[^%]+%)?([^}]+)\}/) {
+          invisible = $1.full?
+          directive = $2
+          key       = $3
+          if value = @event[key]
+            formatted_value =
+              if directive
+                case directive
+                when /\A%O%/
+                  format_object(value)
+                when /\A%([ulif])?t%/
+                  flag = $1
+                  t = case
+                      when v = value.ask_and_send(:to_str)
+                        Time.parse(v)
+                      when v = value.ask_and_send(:to_time)
+                        v
+                      else
+                        Time.at(0)
+                      end
+                  case flag
+                  when ?u then t.utc.iso8601(3)
+                  when ?l then t.localtime.iso8601(3)
+                  when ?i then t.to_i.to_s
+                  when ?f then t.to_f.to_s
+                  else         t.utc.iso8601(3)
+                  end
+                else
+                  begin
+                    directive[0..-2] % value
+                  rescue ArgumentError
+                    value.to_s
+                  end
+                end
+              else
+                value.to_s
+              end
+            colorize(key, value, formatted_value)
+          else
+            unless invisible
+              "{#{key}}"
+            end
+          end
+        }
+    end
+
+    def format_object(object, depth: 0, nl: ?\n)
+      case
+      when a = object.ask_and_send(:to_ary)
+        result = ''
+        depth += 2
+        for v in a
+          result << "\n#{' ' * depth}- #{format_object(v, depth: depth)}"
+        end
+        result
+      when h = object.ask_and_send(:to_hash)
+        result = ''
+        depth += 2
+        for k, v in h
+          result << "\n#{' ' * depth}#{k}: #{format_object(v, depth: depth)}"
+        end
+        result
+      else
+        object.to_s
+      end
+    end
+  end
+end

data/lib/betterlog/log/severity.rb

@@ -0,0 +1,49 @@
+class Log
+  class Severity
+    include Comparable
+
+    def initialize(name)
+      @name = name.to_s.downcase.to_sym
+      begin
+        @level = ActiveSupport::Logger::Severity.const_get(@name.upcase)
+      rescue NameError
+        @name  = :UNKNOWN
+        @level = ActiveSupport::Logger::Severity::UNKNOWN
+      end
+    end
+
+    def self.all
+      ActiveSupport::Logger::Severity.constants.map { |c| new(c) }
+    end
+
+    def to_i
+      @level
+    end
+
+    def to_s
+      @name.to_s.upcase
+    end
+
+    def to_sym
+      @name
+    end
+
+    def as_json(*)
+      to_sym
+    end
+
+    def <=>(other)
+      to_i <=> other.to_i
+    end
+
+    def eql?(other)
+      to_sym == other.to_sym
+    end
+
+    alias == eql?
+
+    def hash
+      @name.hash
+    end
+  end
+end

data/lib/betterlog/log.rb

@@ -0,0 +1,181 @@
+require 'tins'
+require 'tins/xt'
+require 'betterlog/log/event'
+require 'betterlog/log/event_formatter'
+require 'betterlog/log/severity'
+
+class Log
+  include Tins::SexySingleton
+
+  def logger
+    Rails.logger
+  end
+
+  # 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
+
+  # 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
+
+  # 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
+
+  # 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
+
+  # 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
+
+  # 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
+
+  # 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
+
+  # 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
+
+  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
+
+  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 ] * ?:
+    end
+    event[:emitter] = self.class.name.downcase
+    if event.notify?
+      notify(event)
+    end
+    logger.send(event.severity.to_sym, event.to_json)
+    self
+  end
+
+  def notify(event)
+    Honeybadger.notify(event.notify?, event.as_hash)
+  end
+
+  thread_local :timed_duration
+
+  def time_block
+    s = Time.now
+    yield
+  ensure
+    self.timed_duration = Time.now - s
+  end
+end

data/lib/betterlog/log_event_formatter.rb

@@ -0,0 +1,47 @@
+class LogEventFormatter < ActiveSupport::Logger::Formatter
+  include ActiveSupport::TaggedLogging::Formatter
+
+  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'
+          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
+    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/version.rb

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

data/lib/betterlog.rb

@@ -0,0 +1,14 @@
+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'
+require 'betterlog/log'
+require 'betterlog/log_event_formatter'

data/log.yml

@@ -0,0 +1,77 @@
+default: &default
+  styles:
+    'timestamp': [ yellow, bold ]
+    'file': [ blue, bold ]
+    severity:
+      debug: green
+      info: green
+      warn:  yellow
+      error: red
+      fatal: [ red, blink ]
+      unknown: red
+  formats:
+    default: &default_format >
+      {%lt%timestamp} {%5s%severity}
+      "{%0.<%= ENV.fetch('COLUMNS', 80).to_i / 2 %>%message}"
+      {location}
+      {file}{-%O%backtrace}{-%O%meta}
+    d: *default_format
+    long: &long_format |
+      timestamp: {%lt%timestamp}
+      severity: {severity}
+      message: "{message}"
+      metric: {metric} {value} {type}
+      error_class: {error_class}
+      backtrace: {%O%backtrace}
+      location: {location}
+      file: {file}
+      meta: {%O%meta}\n
+    l: *long_format
+    legacy: >
+      {%0.1s%severity} [{%lt%timestamp} #{%d%pid}] {%5s%severity} --
+      {program}: {message}
+    metric: >
+      {%ft%timestamp} {metric} {value} {type}
+
+development:
+  <<: *default
+  config_files:
+    rails:
+      - log/development.log
+    test:
+      - log/test.log
+    redis:
+      - /usr/local/var/log/redis.log
+    elasticsearch:
+      - /usr/local/var/log/elasticsearch@1.7.log
+    nginx:
+      - /usr/local/var/log/nginx/access.log
+      - /usr/local/var/log/nginx/error.log
+  legacy_supported: <%= ENV['LOG_LEGACY_SUPPORTED'].to_i == 1 %>
+
+test:
+  <<: *default
+  config_files:
+    test:
+      - log/test.log
+  legacy_supported: <%= ENV['LOG_LEGACY_SUPPORTED'].to_i == 1 %>
+
+production:
+  <<: *default
+  config_files:
+    rails:
+      - /var/apps/betterplace/current/log/production.log
+    cron:
+      - /var/apps/betterplace/current/log/cron.log
+    nginx:
+      - /var/apps/betterplace/current/log/nginx.assets.access.log
+      - /var/apps/betterplace/current/log/nginx.assets.error.log
+      - /var/apps/betterplace/current/log/nginx.betterplace.access.log
+      - /var/apps/betterplace/current/log/nginx.betterplace.error.log
+      - /var/apps/betterplace/current/log/nginx.default.access.log
+      - /var/apps/betterplace/current/log/nginx.default.error.log
+    memosig:
+      - /var/log/memosig/current
+    unicorn:
+      - /var/log/unicorn/current
+  legacy_supported: yes