scrolls 0.3.7 → 0.9.1

data/test/test_parser.rb

@@ -1,6 +1,6 @@
-require_relative "test_helper"
+require File.expand_path("../test_helper", __FILE__)
 
-class TestScrollsParser < Test::Unit::TestCase
+class TestScrollsParser < Minitest::Test
   include Scrolls::Parser
 
   def test_parse_bool
@@ -79,6 +79,15 @@ class TestScrollsParser < Test::Unit::TestCase
     assert_equal 't="2012-06-19T16:02:35+01:00"', unparse(data)
   end
 
+  def test_unparse_escape_keys
+    html  = "<p>p</p>"
+    slash = "p/p"
+
+    data = { html => "d", slash => "d" }
+    assert_equal '&lt;p&gt;p&lt;&#x2F;p&gt;=d p&#x2F;p=d',
+      unparse(data, escape_keys=true)
+  end
+
   def test_parse_time
     time = Time.new(2012, 06, 19, 16, 02, 35, "+01:00")
     string = "t=2012-06-19T16:02:35+01:00"

data/test/test_scrolls.rb

@@ -1,44 +1,35 @@
-require_relative "test_helper"
+require File.expand_path("../test_helper", __FILE__)
 
-class TestScrolls < Test::Unit::TestCase
+class TestScrolls < Minitest::Test
   def setup
     @out = StringIO.new
-    Scrolls.stream = @out
+    Scrolls.init(
+      :stream => @out
+    )
   end
 
-  def teardown
-    Scrolls.global_context({})
-    # Reset our syslog context
-    Scrolls.facility = Scrolls::LOG_FACILITY
-    Scrolls.add_timestamp = false
-  end
-
-  def test_construct
-    assert_equal StringIO, Scrolls.stream.class
+  def test_default_construct
+    Scrolls.init
+    assert_equal Scrolls::IOLogger, Scrolls.logger.class
   end
 
   def test_default_global_context
+    Scrolls.init(:stream => @out)
     assert_equal Hash.new, Scrolls.global_context
   end
 
   def test_setting_global_context
-    Scrolls.global_context(:g => "g")
-    Scrolls.log(:d => "d")
-    global = @out.string.gsub("\n", 'XX')
-    assert_match /g=g.*d=d/, global
-  end
-  
-  def test_adding_to_global_context
-    Scrolls.global_context(:g => "g")
-    Scrolls.add_global_context(:h => "h")
+    Scrolls.init(
+      :stream => @out,
+      :global_context => {:g => "g"},
+    )
     Scrolls.log(:d => "d")
-    global = @out.string.gsub("\n", 'XX')
-    assert_match /g=g.*h=h.*d=d/, global
+    assert_equal "g=g d=d\n", @out.string
   end
 
   def test_default_context
-    Scrolls.log(:data => "d")
-    assert_equal Hash.new, Scrolls::Log.context
+    Scrolls.log(:d => "d")
+    assert_equal Hash.new, Scrolls.internal.context
   end
 
   def test_setting_context
@@ -48,15 +39,19 @@ class TestScrolls < Test::Unit::TestCase
   end
 
   def test_all_the_contexts
-    Scrolls.global_context(:g => "g")
+    Scrolls.init(
+      :stream => @out,
+      :global_context => {:g => "g"},
+    )
     Scrolls.log(:o => "o") do
       Scrolls.context(:c => "c") do
         Scrolls.log(:ic => "i")
       end
       Scrolls.log(:i => "i")
     end
-    global = @out.string.gsub("\n", 'XX')
-    assert_match /g=g.*at=start.*i=i/, global
+    @out.truncate(37)
+    output = "g=g o=o at=start\ng=g c=c ic=i\ng=g i=i"
+    assert_equal output, @out.string
   end
 
   def test_deeply_nested_context
@@ -89,12 +84,27 @@ class TestScrolls < Test::Unit::TestCase
         raise "Error from inside of context"
       end
       fail "Exception did not escape context block"
-    rescue => e
+    rescue
       Scrolls.log(:o => 'o')
       assert_equal "o=o\n", @out.string
     end
   end
 
+  def test_deeply_nested_context_after_exception
+    Scrolls.log(:o => "o") do
+      begin
+        Scrolls.log(:io => 'io') do
+          raise "Error from inside of nested logging"
+        end
+      rescue
+        Scrolls.log(:o => 'o')
+      end
+    end
+    @out.truncate(124)
+    output = "o=o at=start\nio=io at=start\nio=io at=exception reraise=true class=RuntimeError message=\"Error from inside of nested logging\""
+    assert_equal output, @out.string
+  end
+
   def test_default_time_unit
     assert_equal "seconds", Scrolls.time_unit
   end
@@ -105,8 +115,15 @@ class TestScrolls < Test::Unit::TestCase
   end
 
   def test_setting_incorrect_time_unit
-    assert_raise Scrolls::TimeUnitError do
+    assert_raises Scrolls::TimeUnitError do
       Scrolls.time_unit = "years"
+      Scrolls.log(:tu => "yrs")
+    end
+  end
+
+  def test_unknown_log_level
+    assert_raises Scrolls::LogLevelError do
+      Scrolls.log(:level => "nope")
     end
   end
 
@@ -125,28 +142,28 @@ class TestScrolls < Test::Unit::TestCase
     begin
       raise Exception
     rescue Exception => e
-      Scrolls.log_exception({:test => "exception"}, e)
+      Scrolls.log_exception(e, {:test => "exception"})
     end
 
-    oneline_backtrace = @out.string.gsub("\n", 'XX')
-
-    assert_match /test=exception at=exception.*test_log_exception.*XX.*minitest/,
-      oneline_backtrace
+    oneline_bt = @out.string.gsub("\n", 'XX')
+    assert_match(/test=exception at=exception.*test_log_exception.*XX/, oneline_bt)
   end
 
-  def test_single_line_exceptions
-    Scrolls.single_line_exceptions = true
+  def test_multi_line_exceptions
+    Scrolls.single_line_exceptions = "multi"
     begin
       raise Exception
     rescue Exception => e
-      Scrolls.log_exception({:o => "o"}, e)
+      Scrolls.log_exception(e, {:o => "o"})
     end
-    assert_equal 1, @out.string.scan(/.*site=.*/).size
+
+    oneline_bt = @out.string.gsub("\n", 'XX')
+    assert_match(/o=o at=exception.*test_multi_line_exceptions.*XX/, oneline_bt)
   end
 
   def test_syslog_integration
     Scrolls.stream = 'syslog'
-    assert_equal Scrolls::SyslogLogger, Scrolls.stream.class
+    assert_equal Scrolls::SyslogLogger, Scrolls.internal.logger.class
   end
 
   def test_syslog_facility
@@ -162,7 +179,7 @@ class TestScrolls < Test::Unit::TestCase
   def test_setting_syslog_facility_after_instantiation
     Scrolls.stream = 'syslog'
     Scrolls.facility = 'local7'
-    assert_match /facility=184/, Scrolls.stream.inspect
+    assert_match(/facility=184/, Scrolls.internal.logger.inspect)
   end
 
   def test_add_timestamp
@@ -204,4 +221,24 @@ class TestScrolls < Test::Unit::TestCase
     assert_equal "t=t level=alert\n", @out.string
   end
 
+  def test_sending_string_error
+    Scrolls.error("error")
+    assert_equal "log_message=error\n", @out.string
+  end
+
+  def test_sending_string_fatal
+    Scrolls.fatal("fatal")
+    assert_equal "log_message=fatal\n", @out.string
+  end
+
+  def test_sending_string_warn
+    Scrolls.warn("warn")
+    assert_equal "log_message=warn\n", @out.string
+  end
+
+  def test_sending_string_unknown
+    Scrolls.unknown("unknown")
+    assert_equal "log_message=unknown\n", @out.string
+  end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scrolls
 version: !ruby/object:Gem::Version
-  version: 0.3.7
+  version: 0.9.1
 platform: ruby
 authors:
 - Curt Micol
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-10 00:00:00.000000000 Z
+date: 2021-06-06 00:00:00.000000000 Z
 dependencies: []
 description: Logging, easier, more consistent.
 email:
@@ -25,14 +25,13 @@ files:
 - docs/global-context.md
 - docs/syslog.md
 - lib/scrolls.rb
-- lib/scrolls/atomic.rb
-- lib/scrolls/log.rb
+- lib/scrolls/iologger.rb
+- lib/scrolls/logger.rb
 - lib/scrolls/parser.rb
-- lib/scrolls/syslog.rb
+- lib/scrolls/sysloglogger.rb
 - lib/scrolls/utils.rb
 - lib/scrolls/version.rb
 - scrolls.gemspec
-- test/test_atomic.rb
 - test/test_helper.rb
 - test/test_parser.rb
 - test/test_scrolls.rb
@@ -55,13 +54,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: When do we log? All the time.
 test_files:
-- test/test_atomic.rb
 - test/test_helper.rb
 - test/test_parser.rb
 - test/test_scrolls.rb

data/lib/scrolls/atomic.rb

@@ -1,59 +0,0 @@
-require 'thread'
-
-module Scrolls
-  # The result of issues with an update I made to Scrolls. After talking with
-  # Fabio Kung about a fix I started work on an atomic object, but he added some
-  # fixes to #context without it and then used Headius' atomic gem.
-  #
-  # The code below is the start and cleanup of my atomic object. It's slim on
-  # details and eventually cleaned up around inspiration from Headius' code.
-  #
-  # LICENSE: Apache 2.0
-  #
-  # See Headius' atomic gem here:
-  # https://github.com/headius/ruby-atomic
-  class AtomicObject
-    def initialize(o)
-      @mtx = Mutex.new
-      @o = o
-    end
-
-    def get
-      @mtx.synchronize { @o }
-    end
-
-    def set(n)
-      @mtx.synchronize { @o = n }
-    end
-
-    def verify_set(o, n)
-      return false unless @mtx.try_lock
-      begin
-        return false unless @o.equal? o
-        @o = n
-      ensure
-        @mtx.unlock
-      end
-    end
-  end
-
-  class Atomic < AtomicObject
-    def initialize(v=nil)
-      super(v)
-    end
-
-    def value
-      self.get
-    end
-
-    def value=(v)
-      self.set(v)
-      v
-    end
-
-    def update
-      true until self.verify_set(o = self.get, n = yield(o))
-      n
-    end
-  end
-end

data/lib/scrolls/log.rb

@@ -1,274 +0,0 @@
-require "scrolls/parser"
-require "scrolls/utils"
-require "scrolls/syslog"
-
-module Scrolls
-
-  class TimeUnitError < RuntimeError; end
-
-  module Log
-    extend self
-
-    extend Parser
-    extend Utils
-
-    LOG_LEVEL = (ENV['LOG_LEVEL'] || 6).to_i
-    LOG_LEVEL_MAP = {
-      "emergency" => 0,
-      "alert"     => 1,
-      "critical"  => 2,
-      "error"     => 3,
-      "warning"   => 4,
-      "notice"    => 5,
-      "info"      => 6,
-      "debug"     => 7
-    }
-
-    def context
-      Thread.current[:scrolls_context] ||= {}
-    end
-
-    def context=(h)
-      Thread.current[:scrolls_context] = h
-    end
-
-    def global_context
-      get_global_context
-    end
-
-    def global_context=(data)
-      set_global_context(data)
-    end
-
-    def add_global_context(new_data)
-      default_global_context unless @global_context
-      @global_context.update { |previous_data| previous_data.merge(new_data) }
-    end
-
-    def facility=(f)
-      @facility = LOG_FACILITY_MAP[f] if f
-      if Scrolls::SyslogLogger.opened?
-        Scrolls::SyslogLogger.new(progname, facility)
-      end
-    end
-
-    def facility
-      @facility ||= default_log_facility
-    end
-
-    def stream=(out=nil)
-      @defined = out.nil? ? false : true
-      if out == 'syslog'
-        @stream = Scrolls::SyslogLogger.new(progname, facility)
-      else
-        @stream = sync_stream(out)
-      end
-    end
-
-    def stream
-      @stream ||= sync_stream
-    end
-
-    def time_unit=(u)
-      set_time_unit(u)
-    end
-
-    def time_unit
-      @tunit ||= default_time_unit
-    end
-
-    def add_timestamp=(b)
-      @add_timestamp = !!b
-    end
-
-    def add_timestamp
-      @add_timestamp || false
-    end
-
-    def single_line_exceptions=(b)
-      @single_line_exceptions = !!b
-    end
-
-    def single_line_exceptions?
-      @single_line_exceptions || false
-    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 = get_global_context
-        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 add_timestamp
-
-      unless blk
-        write(logdata)
-      else
-        start = Time.now
-        res = nil
-        log(logdata.merge(:at => "start"))
-        begin
-          res = yield
-        rescue StandardError => e
-          log(logdata.merge(
-            :at           => "exception",
-            :reraise      => true,
-            :class        => e.class,
-            :message      => e.message,
-            :exception_id => e.object_id.abs,
-            :elapsed      => calc_time(start, Time.now)
-          ))
-          raise e
-        end
-        log(logdata.merge(:at => "finish", :elapsed => calc_time(start, Time.now)))
-        res
-      end
-    end
-
-    def log_exception(data, e)
-      sync_stream(STDERR) unless @defined
-
-      # 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 = get_global_context
-        logdata = gc.merge(rawhash)
-      end
-
-      excepdata = {
-        :at           => "exception",
-        :class        => e.class,
-        :message      => e.message,
-        :exception_id => e.object_id.abs
-      }
-
-      if e.backtrace
-        if single_line_exceptions?
-          btlines = []
-          e.backtrace.each do |line|
-            btlines << line.gsub(/[`'"]/, "")
-          end
-
-          if btlines.length > 0
-            squish = { :site => btlines.join('\n') }
-            log(logdata.merge(excepdata.merge(squish)))
-          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 get_global_context
-      default_global_context unless @global_context
-      @global_context.value
-    end
-
-    def set_global_context(data=nil)
-      default_global_context unless @global_context
-      @global_context.update { |_| data }
-    end
-
-    def default_global_context
-      @global_context = Atomic.new({})
-    end
-
-    def set_time_unit(u=nil)
-      unless ["ms","milli","milliseconds","s","seconds"].include?(u)
-        raise TimeUnitError, "Specify only 'seconds' or 'milliseconds'"
-      end
-
-      if ["ms", "milli", "milliseconds", 1000].include?(u)
-        @tunit = "milliseconds"
-        @t = 1000.0
-      else
-        default_time_unit
-      end
-    end
-
-    def default_time_unit
-      @t = 1.0
-      @tunit = "seconds"
-    end
-
-    def calc_time(start, finish)
-      default_time_unit unless @t
-      ((finish - start).to_f * @t)
-    end
-
-    def mtx
-      @mtx ||= Mutex.new
-    end
-
-    def sync_stream(out=nil)
-      out = STDOUT if out.nil?
-      s = out
-      s.sync = true
-      s
-    end
-
-    def write(data)
-      if log_level_ok?(data[:level])
-        msg = unparse(data)
-        mtx.synchronize do
-          begin
-            stream.puts(msg)
-          rescue NoMethodError => e
-            raise
-          end
-        end
-      end
-    end
-
-    def log_level_ok?(level)
-      if level
-        LOG_LEVEL_MAP[level.to_s] <= LOG_LEVEL
-      else
-        true
-      end
-    end
-
-    def progname
-      File.basename($0)
-    end
-
-    def default_log_facility
-      LOG_FACILITY
-    end
-  end
-end