scrolls 0.3.7 → 0.9.1

data/lib/scrolls/iologger.rb

@@ -0,0 +1,14 @@
+module Scrolls
+  class IOLogger
+    def initialize(stream)
+      if stream.respond_to?(:sync)
+        stream.sync = true
+      end
+      @stream = stream
+    end
+
+    def log(data)
+      @stream.write("#{data}\n")
+    end
+  end
+end

data/lib/scrolls/logger.rb

@@ -0,0 +1,318 @@
+require "syslog"
+
+require "scrolls/parser"
+require "scrolls/iologger"
+require "scrolls/sysloglogger"
+require "scrolls/utils"
+
+module Scrolls
+  # Default log facility
+  LOG_FACILITY = ENV['LOG_FACILITY'] || Syslog::LOG_USER
+
+  # Default log level
+  LOG_LEVEL = (ENV['LOG_LEVEL'] || 6).to_i
+
+  # Default syslog options
+  SYSLOG_OPTIONS = Syslog::LOG_PID|Syslog::LOG_CONS
+
+  class TimeUnitError < RuntimeError; end
+  class LogLevelError < StandardError; end
+
+  # Top level class to hold our global context
+  #
+  # Global context is defined using Scrolls#init
+  class GlobalContext
+    def initialize(ctx)
+      @ctx = ctx || {}
+    end
+
+    def to_h
+      @ctx
+    end
+  end
+
+  class Logger
+
+    attr_reader :logger
+    attr_accessor :exceptions, :timestamp
+
+    def initialize(options={})
+      @stream       = options.fetch(:stream, STDOUT)
+      @log_facility = options.fetch(:facility, LOG_FACILITY)
+      @time_unit    = options.fetch(:time_unit, "seconds")
+      @timestamp    = options.fetch(:timestamp, false)
+      @exceptions   = options.fetch(:exceptions, "single")
+      @global_ctx   = options.fetch(:global_context, {})
+      @syslog_opts  = options.fetch(:syslog_options, SYSLOG_OPTIONS)
+      @escape_keys  = options.fetch(:escape_keys, false)
+
+      # Our main entry point to ensure our options are setup properly
+      setup!
+    end
+
+    def context
+      if Thread.current.thread_variables.include?(:scrolls_context)
+        Thread.current.thread_variable_get(:scrolls_context)
+      else
+        Thread.current.thread_variable_set(:scrolls_context, {})
+      end
+    end
+
+    def context=(h)
+      Thread.current.thread_variable_set(:scrolls_context, h || {})
+    end
+
+    def stream
+      @stream
+    end
+
+    def stream=(s)
+      # Return early to avoid setup
+      return if s == @stream
+
+      @stream = s
+      setup_stream
+    end
+
+    def escape_keys?
+      @escape_keys
+    end
+
+    def syslog_options
+      @syslog_opts
+    end
+
+    def facility
+      @facility
+    end
+
+    def facility=(f)
+      if f
+        setup_facility(f)
+        # If we are using syslog, we need to setup our connection again
+        if stream == "syslog"
+          @logger = Scrolls::SyslogLogger.new(
+                      progname,
+                      syslog_options,
+                      facility
+                    )
+        end
+      end
+    end
+
+    def time_unit
+      @time_unit
+    end
+
+    def time_unit=(u)
+      @time_unit = u
+      setup_time_unit
+    end
+
+    def global_context
+      @global_context.to_h
+    end
+
+    def log(data, &blk)
+      # If we get a string lets bring it into our structure.
+      if data.kind_of? String
+        rawhash = { "log_message" => data }
+      else
+        rawhash = data
+      end
+
+      if gc = @global_context.to_h
+        ctx = gc.merge(context)
+        logdata = ctx.merge(rawhash)
+      end
+
+      # By merging the logdata into the timestamp, rather than vice-versa, we
+      # ensure that the timestamp comes first in the Hash, and is placed first
+      # on the output, which helps with readability.
+      logdata = { :now => Time.now.utc }.merge(logdata) if prepend_timestamp?
+
+      unless blk
+        write(logdata)
+      else
+        start = Time.now
+        res = nil
+        log(logdata.merge(:at => "start"))
+        begin
+          res = yield
+        rescue StandardError => e
+          logdata.merge!({
+            at:           "exception",
+            reraise:      true,
+            class:        e.class,
+            message:      e.message,
+            exception_id: e.object_id.abs,
+            elapsed:      calculate_time(start, Time.now)
+          })
+          logdata.delete_if { |k,v| k if v == "" }
+          log(logdata)
+          raise e
+        end
+        log(logdata.merge(:at => "finish", :elapsed => calculate_time(start, Time.now)))
+        res
+      end
+    end
+
+    def log_exception(e, data=nil)
+      unless @defined
+        @stream = STDERR
+        setup_stream
+      end
+
+      # We check our arguments for type
+      case data
+      when String
+        rawhash = { "log_message" => data }
+      when Hash
+        rawhash = data
+      else
+        rawhash = {}
+      end
+
+      if gc = @global_context.to_h
+        logdata = gc.merge(rawhash)
+      end
+
+      excepdata = {
+        at:           "exception",
+        class:        e.class,
+        message:      e.message,
+        exception_id: e.object_id.abs
+      }
+
+      excepdata.delete_if { |k,v| k if v == "" }
+
+      if e.backtrace
+        if single_line_exceptions?
+          lines = e.backtrace.map { |line| line.gsub(/[`'"]/, "") }
+
+          if lines.length > 0
+            excepdata[:site] = lines.join('\n')
+            log(logdata.merge(excepdata))
+          end
+        else
+          log(logdata.merge(excepdata))
+
+          e.backtrace.each do |line|
+            log(logdata.merge(excepdata).merge(
+              :at           => "exception",
+              :class        => e.class,
+              :exception_id => e.object_id.abs,
+              :site         => line.gsub(/[`'"]/, "")
+            ))
+          end
+        end
+      end
+    end
+
+    def with_context(prefix)
+      return unless block_given?
+      old = context
+      self.context = old.merge(prefix)
+      res = yield if block_given?
+    ensure
+      self.context = old
+      res
+    end
+
+    private
+
+    def setup!
+      setup_global_context
+      prepend_timestamp?
+      setup_facility
+      setup_stream
+      single_line_exceptions?
+      setup_time_unit
+    end
+
+    def setup_global_context
+      # Builds up an immutable object for our global_context
+      # This is not backwards compatiable and was introduced after 0.3.7.
+      # Removes ability to add to global context once we initialize our
+      # logging object. This also deprecates #add_global_context.
+      @global_context = GlobalContext.new(@global_ctx)
+      @global_context.freeze
+    end
+
+    def prepend_timestamp?
+      @timestamp
+    end
+
+    def setup_facility(f=nil)
+      if f
+        @facility = LOG_FACILITY_MAP.fetch(f, LOG_FACILITY)
+      else
+        @facility = LOG_FACILITY_MAP.fetch(@log_facility, LOG_FACILITY)
+      end
+    end
+
+    def setup_stream
+      unless @stream == STDOUT
+        # Set this so we know we aren't using our default stream
+        @defined = true
+      end
+
+      if @stream == "syslog"
+        @logger = Scrolls::SyslogLogger.new(
+                    progname,
+                    syslog_options,
+                    facility
+                  )
+      else
+        @logger = IOLogger.new(@stream)
+      end
+    end
+
+    def single_line_exceptions?
+      return false if @exceptions == "multi"
+      true
+    end
+
+    def setup_time_unit
+      unless %w{s ms seconds milliseconds}.include? @time_unit
+        raise TimeUnitError, "Specify the following: s, ms, seconds, milliseconds"
+      end
+
+      case @time_unit
+      when %w{s seconds}
+        @t = 1.0
+      when %w{ms milliseconds}
+        @t = 1000.0
+      else
+        @t = 1.0
+      end
+    end
+
+    # We need this for our syslog setup
+    def progname
+      File.basename($0)
+    end
+
+    def calculate_time(start, finish)
+      translate_time_unit unless @t
+      ((finish - start).to_f * @t)
+    end
+
+    def log_level_ok?(level)
+      if level
+        raise LogLevelError, "Log level unknown" unless LOG_LEVEL_MAP.key?(level)
+        LOG_LEVEL_MAP[level.to_s] <= LOG_LEVEL
+      else
+        true
+      end
+    end
+
+    def write(data)
+      if log_level_ok?(data[:level])
+        msg = Scrolls::Parser.unparse(data, escape_keys=escape_keys?)
+        @logger.log(msg)
+      end
+    end
+
+  end
+end

data/lib/scrolls/parser.rb

@@ -4,8 +4,10 @@ module Scrolls
   module Parser
     extend self
 
-    def unparse(data)
+    def unparse(data, escape_keys=false)
       data.map do |(k,v)|
+        k = Scrolls::Utils.escape_chars(k) if escape_keys
+
         if (v == true)
           "#{k}=true"
         elsif (v == false)

data/lib/scrolls/sysloglogger.rb

@@ -0,0 +1,17 @@
+module Scrolls
+  class SyslogLogger
+    def initialize(ident = 'scrolls',
+                   options = Scrolls::SYSLOG_OPTIONS,
+                   facility = Scrolls::LOG_FACILITY)
+      if Syslog.opened?
+        @syslog = Syslog.reopen(ident, options, facility)
+      else
+        @syslog = Syslog.open(ident, options, facility)
+      end
+    end
+
+    def log(data)
+      @syslog.log(Syslog::LOG_INFO, "%s", data)
+    end
+  end
+end

data/lib/scrolls/utils.rb

@@ -1,19 +1,61 @@
 module Scrolls
-  module Utils
 
-    def hashify(d)
-      last = d.pop
-      return {} unless last
-      return hashified_list(d).merge(last) if last.is_a?(Hash)
-      d.push(last)
-      hashified_list(d)
-    end
+  # Helpful map of syslog facilities
+  LOG_FACILITY_MAP = {
+    "auth"     => Syslog::LOG_AUTH,
+    "authpriv" => Syslog::LOG_AUTHPRIV,
+    "cron"     => Syslog::LOG_CRON,
+    "daemon"   => Syslog::LOG_DAEMON,
+    "ftp"      => Syslog::LOG_FTP,
+    "kern"     => Syslog::LOG_KERN,
+    "mail"     => Syslog::LOG_MAIL,
+    "news"     => Syslog::LOG_NEWS,
+    "syslog"   => Syslog::LOG_SYSLOG,
+    "user"     => Syslog::LOG_USER,
+    "uucp"     => Syslog::LOG_UUCP,
+    "local0"   => Syslog::LOG_LOCAL0,
+    "local1"   => Syslog::LOG_LOCAL1,
+    "local2"   => Syslog::LOG_LOCAL2,
+    "local3"   => Syslog::LOG_LOCAL3,
+    "local4"   => Syslog::LOG_LOCAL4,
+    "local5"   => Syslog::LOG_LOCAL5,
+    "local6"   => Syslog::LOG_LOCAL6,
+    "local7"   => Syslog::LOG_LOCAL7,
+  }
+
+  # Helpful map of syslog log levels
+  LOG_LEVEL_MAP = {
+    "emerg"     => 0, # Syslog::LOG_EMERG
+    "emergency" => 0, # Syslog::LOG_EMERG
+    "alert"     => 1, # Syslog::LOG_ALERT
+    "crit"      => 2, # Syslog::LOG_CRIT
+    "critical"  => 2, # Syslog::LOG_CRIT
+    "error"     => 3, # Syslog::LOG_ERR
+    "warn"      => 4, # Syslog::LOG_WARNING
+    "warning"   => 4, # Syslog::LOG_WARNING
+    "notice"    => 5, # Syslog::LOG_NOTICE
+    "info"      => 6, # Syslog::LOG_INFO
+    "debug"     => 7  # Syslog::LOG_DEBUG
+  }
+
+  ESCAPE_CHAR = {
+    "&" => "&",
+    "<" => "&lt;",
+    ">" => "&gt;",
+    "'" => "&#x27;",
+    '"' => "&quot;",
+    "/" => "&#x2F;"
+  }
+
+  ESCAPE_CHAR_PATTERN = Regexp.union(*ESCAPE_CHAR.keys)
+
+  module Utils
 
-    def hashified_list(l)
-      return {} if l.empty?
-      l.inject({}) do |h, i|
-        h[i.to_sym] = true
-        h
+    def self.escape_chars(d)
+      if d.is_a?(String) and d =~ ESCAPE_CHAR_PATTERN
+        esc = d.to_s.gsub(ESCAPE_CHAR_PATTERN) {|c| ESCAPE_CHAR[c] }
+      else
+        esc = d
       end
     end
 

data/lib/scrolls/version.rb

@@ -1,3 +1,3 @@
 module Scrolls
-  VERSION = "0.3.7"
+  VERSION = "0.9.1"
 end

data/test/test_helper.rb

@@ -1,6 +1,9 @@
-require "test/unit"
+require "minitest/autorun"
+require "minitest/reporters"
 require "stringio"
 
+Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
+
 $: << File.expand_path("../../lib", __FILE__)
 
 require "scrolls"