betterlog 0.1.0 → 0.2.0

data/lib/betterlog/global_metadata.rb

@@ -3,21 +3,16 @@
 # thread-global, this will also attempt to update context of error reporting
 # tools etc.
 
-class GlobalMetadata
-  include Tins::SexySingleton
+module Betterlog
+  class GlobalMetadata
+    include Tins::SexySingleton
 
-  def data
-    Thread.current['BP_GLOBAL_METATDATA'] || {}
-  end
-
-  def add(data_hash)
-    data = data_hash | data
-    Honeybadger.context(data_hash)
-  end
-
-  private
+    thread_local(:data) { {} }
 
-  def data=(value)
-    Thread.current['BP_GLOBAL_METATDATA'] = value
+    def add(data_hash)
+      data = data_hash | data
+      Notifiers.context(data_hash)
+      self
+    end
   end
 end

data/lib/betterlog/log/event.rb

@@ -1,163 +1,165 @@
-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,
+module Betterlog
+  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
-        )
-      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
-        )
+            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
-    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')
+      def self.parse(json)
+        new(JSON.parse(json))
+      rescue JSON::ParserError
       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)
+      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
-      @data = Hash[data.sort_by(&:first)]
-    end
+      rescue JSON::ParserError
+        false
+      end
 
-    class BreakCircles
-      def initialize
-        @seen   = {}
+      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
 
-      IN_JSON = Tins::ModuleGroup[
-        Float, Integer, NilClass, FalseClass, TrueClass
-      ]
+      class BreakCircles
+        def initialize
+          @seen   = {}
+        end
 
-      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
+        IN_JSON = Tins::ModuleGroup[
+          Float, Integer, NilClass, FalseClass, TrueClass
+        ]
+
+        def perform(object)
+          if @seen.key?(object.__id__)
+            :circular
           else
-            object.to_s
+            @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
-    end
 
-    def as_hash(*a)
-      BreakCircles.new.perform(@data)
-    end
+      def as_hash(*a)
+        BreakCircles.new.perform(@data)
+      end
 
-    def to_json(*a)
-      as_hash.to_json(*a)
-    end
+      def to_json(*a)
+        as_hash.to_json(*a)
+      end
 
-    def format(*args)
-      Log::EventFormatter.new(self).format(*args)
-    end
+      def format(*args)
+        Log::EventFormatter.new(self).format(*args)
+      end
 
-    alias to_s format
+      alias to_s format
 
-    def []=(name, value)
-      @data[name.to_sym] = value
-    end
+      def []=(name, value)
+        @data[name.to_sym] = value
+      end
 
-    def [](name)
-      @data[name.to_sym]
-    end
+      def [](name)
+        @data[name.to_sym]
+      end
 
-    def severity
-      @data[:severity]
-    end
+      def severity
+        @data[:severity]
+      end
 
-    def emitter
-      @data[:emitter]
-    end
+      def emitter
+        @data[:emitter]
+      end
 
-    def notify?
-      @data[:notify]
-    end
+      def notify?
+        @data[:notify]
+      end
 
-    def eql?(other)
-      @data.eql? other.instance_variable_get(:@data)
-    end
+      def eql?(other)
+        @data.eql? other.instance_variable_get(:@data)
+      end
 
-    alias == eql?
+      alias == eql?
 
-    def hash
-      @data.hash
-    end
+      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
+      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
 end

data/lib/betterlog/log/event_formatter.rb

@@ -1,116 +1,118 @@
-class Log
-  class EventFormatter
-    include Term::ANSIColor
+module Betterlog
+  class Log
+    class EventFormatter
+      include Term::ANSIColor
 
-    def initialize(event)
-      @event = event
-    end
+      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
+      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
-    ensure
-      Term::ANSIColor.coloring = old_coloring
-    end
 
-    private
+      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)
+      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
-    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)
+      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
-    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)
+      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
-                  begin
-                    directive[0..-2] % value
-                  rescue ArgumentError
-                    value.to_s
-                  end
+                  value.to_s
                 end
-              else
-                value.to_s
+              colorize(key, value, formatted_value)
+            else
+              unless invisible
+                "{#{key}}"
               end
-            colorize(key, value, formatted_value)
-          else
-            unless invisible
-              "{#{key}}"
             end
-          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)}"
+      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
-        result
-      else
-        object.to_s
       end
     end
   end

data/lib/betterlog/log/severity.rb

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