scrolls 0.9.0.pre → 0.9.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: b78c2d850fe048ad6f192be59e56b6d04daee1c5
-  data.tar.gz: 49934f36ea64c5fe6a8a1b44ecb5689ea4574a75
+SHA256:
+  metadata.gz: 2c46a03de696acee9e14e71d9e2a373415e9fa60532a7ac51896f71b5e0286ca
+  data.tar.gz: 9d9af16e271f1ff468fb778c8d5e05d9f215909adf77cdbf144204d2b3d8836e
 SHA512:
-  metadata.gz: 9d05994bb1dfdd62a76ad372a56ac83270fe8853e19f5f402d86031e90b22eec8ff09f26d3208efe91e392a6b2d6391a56c8236eb3b6d29390183cbd8abf58ef
-  data.tar.gz: c45dca818ec283f03f238de1201d5ea70198375b55a458e5a1441f2f8fa069f85198894cd11827496541084cd403ae356b6b9ce40376a499876f72be44f183fc
+  metadata.gz: 9aa2a50b5c00379872e54384b8f0b6050f82ab5f86e66bb2eca544a7ea5845ac4672dcc758e948d9b3af84b6d61af7972ca937be21854010002325c89b176865
+  data.tar.gz: 992fc115e62d9a2ea39305a72db4bfd0868c0f64d2e1a47082136ecf01e2d7a16461bbfb69e5bb38da628a4e1331685c4f6da275277e9793dfe5c5a8a808c496

data/Gemfile

@@ -4,5 +4,7 @@ source 'https://rubygems.org'
 gemspec
 
 group :test do
+  gem "minitest", require: 'minitest/autorun'
+  gem "minitest-reporters"
   gem "rake"
 end

data/LICENSE

@@ -1,7 +1,7 @@
 The MIT License (MIT)
 
-Copyright © Curt Micol <asenchi@asenchi.com> 2012,2013,2014
-Copyright © Heroku 2012
+Copyright (c) 2013-2021 Curt Micol <asenchi@asenchi.com>
+Copyright (c) 2012, Heroku
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -20,26 +20,65 @@ Or install it yourself as:
 
 Scrolls follows the belief that logs should be treated as data. One way to think of them is the blood of your infrastructure. Logs are a realtime view of what is happening on your systems.
 
-## Need to know!
+## Usage
+
+### 0.9.0 and later
 
-The way Scrolls handles "global_context" is changing after v0.3.8. Please see the [release notes](https://github.com/asenchi/scrolls/releases/tag/v0.3.8) and [this documentation](https://github.com/asenchi/scrolls/tree/master/docs/global-context.md) for more information. I apologize for any trouble this may cause.
+```ruby
+require 'scrolls'
 
-## Documentation:
+Scrolls.init(
+  timestamp: true,
+  global_context: {app: "scrolls", deploy: "production"},
+  exceptions: "multi"
+)
 
-I apologize, some of these are a WIP.
+Scrolls.log(at: "test")
 
-* [Sending logs to syslog using Scrolls](https://github.com/asenchi/scrolls/tree/master/docs/syslog.md)
-* Logging contexts
-* Adding timestamps by default
-* Misc Features
+Scrolls.context(context: "block") do
+  Scrolls.log(at: "exec")
+end
 
-## Usage
+begin
+  raise
+rescue Exception => e
+  Scrolls.log_exception(e, at: "raise")
+end
+```
+
+You can also use `Scrolls#log` and `Scrolls#log_exception` without initalizing:
+
+```ruby
+require 'scrolls'
+
+Scrolls.log(test: "test")
+```
+
+### Defaults
+
+Here are the defaults `Scrolls#init`:
+
+```
+stream: STDOUT
+facility: Syslog::LOG_USER
+time_unit: "seconds"
+timestamp: false
+exceptions: "single"
+global_context: {}
+syslog_options: Syslog::LOG_PID|Syslog::LOG_CONS
+escape_keys: false
+strict_logfmt: false
+```
+
+## Older Versions
+
+### Pre 0.9.0
 
 ```ruby
 require 'scrolls'
 
 Scrolls.add_timestamp = true
-Scrolls.global_context(:app => "scrolls", :deploy => ENV["DEPLOY"])
+Scrolls.global_context(:app => "scrolls", :deploy => "production")
 
 Scrolls.log(:at => "test")
 
@@ -57,10 +96,10 @@ end
 Produces:
 
 ```
-now="2014-01-17T16:11:39Z" app=scrolls deploy=nil at=test
-now="2014-01-17T16:11:39Z" app=scrolls deploy=nil context=block at=exec
-now="2014-01-17T16:11:39Z" app=scrolls deploy=nil at=exception class=RuntimeError message= exception_id=70312608019740
-now="2014-01-17T16:11:39Z" app=scrolls deploy=nil at=exception class= exception_id=70312608019740 site="./test.rb:16:in <main>"
+now="2017-09-01T00:37:13Z" app=scrolls deploy=production at=test
+now="2017-09-01T00:37:13Z" app=scrolls deploy=production context=block at=exec
+now="2017-09-01T00:37:13Z" app=scrolls deploy=production at=exception class=RuntimeError exception_id=70149797587080
+now="2017-09-01T00:37:13Z" app=scrolls deploy=production at=exception class=RuntimeError exception_id=70149797587080 site="./test-scrolls.rb:16:in <main>"
 ```
 
 ## History

data/Rakefile

@@ -1,11 +1,13 @@
 #!/usr/bin/env rake
+
 require "bundler/gem_tasks"
+require "rake/testtask"
 
 ENV['TESTOPTS'] = "-v"
 
-require "rake/testtask"
 Rake::TestTask.new do |t|
-  t.pattern = "test/test_*.rb"
+  t.test_files = FileList["test/**/test_*.rb"]
+  t.verbose = true
 end
 
 task :default => :test

data/docs/global-context.md

@@ -38,7 +38,7 @@ Scrolls.init(
 Scrolls.log(:t => "t")
 ```
 
-Is the same as this currently:
+Is the same as this in versions prior to 0.9.0:
 
 ```ruby
 Scrolls.global_context(:g => "g")

data/docs/syslog.md

@@ -6,6 +6,14 @@ By default Scrolls writes log messages to `STDOUT`. With the release of [v0.2.8]
 Scrolls.stream = "syslog"
 ```
 
+Or using `Scrolls#init` in versions 0.9.0 and after:
+
+```ruby
+Scrolls.init(
+    stream: "syslog"
+)
+```
+
 This defaults to syslog facility USER and log level ERROR. You can adjust the log facility like so:
 
 ```ruby
@@ -14,4 +22,9 @@ Scrolls.facility = "local7"
 
 Scrolls generally doesn't care about log levels. The library defaults to ERROR (or 3), but ultimately is of the opinion that levels are useless. The reasoning behind this is that applications should log useful data, all of the time. Debugging data is great for development, but should never be deployed. The richness of structured logging allows exceptions and error messages to sit along side the context of the data in which the error was thrown, there is no need to send to an "emergency" level.
 
-With that said, if one wanted to adjust the log level, you can set an environment variable `LOG_LEVEL`. This allows this particular feature to be rather fluid throughout your application.
+With that said, if one wanted to adjust the log level, you can set an environment variable `LOG_LEVEL` or use one of the level methods. This allows this particular feature to be rather fluid throughout your application.
+
+```ruby
+Scrolls.info(d: "data")
+Scrolls.warn(d: "data")
+```

data/lib/scrolls/{iolog.rb → iologger.rb}

@@ -1,5 +1,5 @@
 module Scrolls
-  class IOLog
+  class IOLogger
     def initialize(stream)
       if stream.respond_to?(:sync)
         stream.sync = true

data/lib/scrolls/logger.rb

@@ -1,100 +1,107 @@
+require "syslog"
+
 require "scrolls/parser"
-require "scrolls/iolog"
-require "scrolls/syslog"
+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
-    attr_reader :context
-    def initialize(context)
-      @context = context || {}
+    def initialize(ctx)
+      @ctx = ctx || {}
     end
 
     def to_h
-      @context
+      @ctx
     end
   end
 
-  class Log
-    LOG_FACILITY = ENV['LOG_FACILITY'] || Syslog::LOG_USER
-    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,
-    }
-
-    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
-    }
+  class Logger
 
     attr_reader :logger
     attr_accessor :exceptions, :timestamp
 
     def initialize(options={})
-      @stream     = options.fetch(:stream, sync_stream)
-      @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, {})
-
+      @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)
+      @strict_logfmt = options.fetch(:strict_logfmt, false)
+
+      # Our main entry point to ensure our options are setup properly
       setup!
     end
 
     def context
-      Thread.current[:scrolls_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[:scrolls_context] = h
+      Thread.current.thread_variable_set(:scrolls_context, h || {})
     end
 
     def stream
       @stream
     end
 
-    def stream=(stream)
+    def stream=(s)
       # Return early to avoid setup
-      return if stream == @stream
-      
-      @stream = stream
+      return if s == @stream
+
+      @stream = s
       setup_stream
     end
 
+    def escape_keys?
+      @escape_keys
+    end
+
+    def strict_logfmt?
+      @strict_logfmt
+    end
+
+    def syslog_options
+      @syslog_opts
+    end
+
     def facility
-      @facility ||= LOG_FACILITY
+      @facility
     end
 
     def facility=(f)
       if f
-        @facility = LOG_FACILITY_MAP[f]
-        # Assume we are using syslog and set it up again
-        @logger = Scrolls::SyslogLogger.new(progname, facility)
+        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
 
@@ -104,7 +111,7 @@ module Scrolls
 
     def time_unit=(u)
       @time_unit = u
-      translate_time_unit
+      setup_time_unit
     end
 
     def global_context
@@ -138,14 +145,16 @@ module Scrolls
         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      => calculate_time(start, Time.now)
-          ))
+          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)))
@@ -153,17 +162,20 @@ module Scrolls
       end
     end
 
-    def log_exception(data, e)
+    def log_exception(e, data=nil)
       unless @defined
         @stream = STDERR
         setup_stream
       end
 
-      # If we get a string lets bring it into our structure.
-      if data.kind_of? String
+      # We check our arguments for type
+      case data
+      when String
         rawhash = { "log_message" => data }
-      else
+      when Hash
         rawhash = data
+      else
+        rawhash = {}
       end
 
       if gc = @global_context.to_h
@@ -171,12 +183,14 @@ module Scrolls
       end
 
       excepdata = {
-        :at           => "exception",
-        :class        => e.class,
-        :message      => e.message,
-        :exception_id => e.object_id.abs
+        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(/[`'"]/, "") }
@@ -213,14 +227,15 @@ module Scrolls
     private
 
     def setup!
-      build_global_context
+      setup_global_context
       prepend_timestamp?
+      setup_facility
       setup_stream
       single_line_exceptions?
-      translate_time_unit
+      setup_time_unit
     end
 
-    def build_global_context
+    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
@@ -233,15 +248,28 @@ module Scrolls
       @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, facility)
+        @logger = Scrolls::SyslogLogger.new(
+                    progname,
+                    syslog_options,
+                    facility
+                  )
       else
-        @logger = sync_stream(@stream)
+        @logger = IOLogger.new(@stream)
       end
     end
 
@@ -250,7 +278,7 @@ module Scrolls
       true
     end
 
-    def translate_time_unit
+    def setup_time_unit
       unless %w{s ms seconds milliseconds}.include? @time_unit
         raise TimeUnitError, "Specify the following: s, ms, seconds, milliseconds"
       end
@@ -264,11 +292,8 @@ module Scrolls
         @t = 1.0
       end
     end
-    
-    def sync_stream(out = STDOUT)
-      IOLog.new(out)
-    end
 
+    # We need this for our syslog setup
     def progname
       File.basename($0)
     end
@@ -280,6 +305,7 @@ module Scrolls
 
     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
@@ -288,8 +314,8 @@ module Scrolls
 
     def write(data)
       if log_level_ok?(data[:level])
-        msg = Scrolls::Parser.unparse(data)
-        logger.log(msg)
+        msg = Scrolls::Parser.unparse(data, escape_keys=escape_keys?, strict_logfmt=strict_logfmt?)
+        @logger.log(msg)
       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, strict_logfmt=false)
       data.map do |(k,v)|
+        k = Scrolls::Utils.escape_chars(k) if escape_keys
+
         if (v == true)
           "#{k}=true"
         elsif (v == false)
@@ -21,7 +23,7 @@ module Scrolls
           has_single_quote = v.index("'")
           has_double_quote = v.index('"')
           if v =~ /[ =:,]/
-            if has_single_quote && has_double_quote
+            if (has_single_quote || strict_logfmt) && has_double_quote
               v = '"' + v.gsub(/\\|"/) { |c| "\\#{c}" } + '"'
             elsif has_double_quote
               v = "'" + v.gsub('\\', '\\\\\\') + "'"

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.9.0.pre"
+  VERSION = "0.9.4"
 end

data/lib/scrolls.rb

@@ -1,4 +1,3 @@
-require "thread"
 require "scrolls/logger"
 require "scrolls/version"
 
@@ -8,9 +7,26 @@ module Scrolls
   # Public: Initialize a Scrolls logger
   #
   # options - A hash of key/values for configuring Scrolls
+  #   stream         - Stream to output data (default: STDOUT)
+  #   log_facility   - Syslog facility (default: Syslog::LOG_USER)
+  #   time_unit      - Unit of time (default: seconds)
+  #   timestamp      - Prepend logs with a timestamp (default: false)
+  #   exceptions     - Method for outputting exceptions (default: single line)
+  #   global_context - Immutable context to prepend all messages with
+  #   syslog_options - Syslog options (default: Syslog::LOG_PID|Syslog::LOG_CONS)
+  #   escape_keys    - Escape chars in keys
+  #   strict_logfmt  - Always use double quotes to quote values
   #
   def init(options={})
-    @log = Log.new(options)
+    # Set a hint whether #init was called.
+    @initialized = true
+    @log = Logger.new(options)
+  end
+
+  # Public: Get the primary logger
+  #
+  def logger
+    @log.logger
   end
 
   # Public: Set a context in a block for logs
@@ -48,26 +64,32 @@ module Scrolls
   #   => nil
   #
   def log(data, &blk)
+    # Allows us to call #log directly and initialize defaults
+    @log = Logger.new({}) unless @initialized
+
     @log.log(data, &blk)
   end
 
   # Public: Log an exception
   #
-  # data - A hash of key/values to log
   # e    - An exception to pass to the logger
+  # data - A hash of key/values to log
   #
   # Examples:
   #
   #   begin
   #     raise Exception
   #   rescue Exception => e
-  #     Scrolls.log_exception({test: "test"}, e)
+  #     Scrolls.log_exception(e, {test: "test"})
   #   end
   #   test=test at=exception class=Exception message=Exception exception_id=70321999017240
   #   ...
   #
-  def log_exception(data, e)
-    @log.log_exception(data, e)
+  def log_exception(e, data)
+    # Allows us to call #log directly and initialize defaults
+    @log = Logger.new({}) unless @initialized
+
+    @log.log_exception(e, data)
   end
 
   # Public: Setup a logging facility (default: Syslog::LOG_USER)
@@ -200,6 +222,7 @@ module Scrolls
   #   => nil
   #
   def debug(data, &blk)
+    data = coalesce_strings_to_hash(data)
     data = data.merge(:level => "debug") if data.is_a?(Hash)
     @log.log(data, &blk)
   end
@@ -218,6 +241,7 @@ module Scrolls
   #   => nil
   #
   def error(data, &blk)
+    data = coalesce_strings_to_hash(data)
     data = data.merge(:level => "warning") if data.is_a?(Hash)
     @log.log(data, &blk)
   end
@@ -236,6 +260,7 @@ module Scrolls
   #   => nil
   #
   def fatal(data, &blk)
+    data = coalesce_strings_to_hash(data)
     data = data.merge(:level => "error") if data.is_a?(Hash)
     @log.log(data, &blk)
   end
@@ -254,6 +279,7 @@ module Scrolls
   #   => nil
   #
   def info(data, &blk)
+    data = coalesce_strings_to_hash(data)
     data = data.merge(:level => "info") if data.is_a?(Hash)
     @log.log(data, &blk)
   end
@@ -272,6 +298,7 @@ module Scrolls
   #   => nil
   #
   def warn(data, &blk)
+    data = coalesce_strings_to_hash(data)
     data = data.merge(:level => "notice") if data.is_a?(Hash)
     @log.log(data, &blk)
   end
@@ -290,6 +317,7 @@ module Scrolls
   #   => nil
   #
   def unknown(data, &blk)
+    data = coalesce_strings_to_hash(data)
     data = data.merge(:level => "alert") if data.is_a?(Hash)
     @log.log(data, &blk)
   end
@@ -300,4 +328,8 @@ module Scrolls
     @log
   end
 
+  def coalesce_strings_to_hash(string_or_something_else)
+    return string_or_something_else unless string_or_something_else.is_a?(String)
+    { "log_message" => string_or_something_else }
+  end
 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"

data/test/test_parser.rb

@@ -1,6 +1,6 @@
 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,21 @@ 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_unparse_strict_logfmt
+    data = { s: 'echo "hello"' }
+    assert_equal 's="echo \"hello\""', unparse(data, escape_keys=false, strict_logfmt=true)
+    assert_equal data.inspect, parse(unparse(data, escape_keys=false, strict_logfmt=true)).inspect
+  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,6 +1,6 @@
 require File.expand_path("../test_helper", __FILE__)
 
-class TestScrolls < Test::Unit::TestCase
+class TestScrolls < Minitest::Test
   def setup
     @out = StringIO.new
     Scrolls.init(
@@ -8,12 +8,9 @@ class TestScrolls < Test::Unit::TestCase
     )
   end
 
-  def teardown
-  end
-
   def test_default_construct
     Scrolls.init
-    assert_equal Scrolls::IOLog, Scrolls.stream.class
+    assert_equal Scrolls::IOLogger, Scrolls.logger.class
   end
 
   def test_default_global_context
@@ -93,6 +90,21 @@ class TestScrolls < Test::Unit::TestCase
     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
@@ -103,12 +115,18 @@ 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
+
   def test_logging
     Scrolls.log(:test => "basic")
     assert_equal "test=basic\n", @out.string
@@ -124,7 +142,7 @@ 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_bt = @out.string.gsub("\n", 'XX')
@@ -136,7 +154,7 @@ class TestScrolls < Test::Unit::TestCase
     begin
       raise Exception
     rescue Exception => e
-      Scrolls.log_exception({:o => "o"}, e)
+      Scrolls.log_exception(e, {:o => "o"})
     end
 
     oneline_bt = @out.string.gsub("\n", 'XX')
@@ -205,22 +223,22 @@ class TestScrolls < Test::Unit::TestCase
 
   def test_sending_string_error
     Scrolls.error("error")
-    assert_equal "log_message=error\n", @out.string
+    assert_equal "log_message=error level=warning\n", @out.string
   end
 
   def test_sending_string_fatal
     Scrolls.fatal("fatal")
-    assert_equal "log_message=fatal\n", @out.string
+    assert_equal "log_message=fatal level=error\n", @out.string
   end
 
   def test_sending_string_warn
     Scrolls.warn("warn")
-    assert_equal "log_message=warn\n", @out.string
+    assert_equal "log_message=warn level=notice\n", @out.string
   end
 
   def test_sending_string_unknown
     Scrolls.unknown("unknown")
-    assert_equal "log_message=unknown\n", @out.string
+    assert_equal "log_message=unknown level=alert\n", @out.string
   end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scrolls
 version: !ruby/object:Gem::Version
-  version: 0.9.0.pre
+  version: 0.9.4
 platform: ruby
 authors:
 - Curt Micol
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-23 00:00:00.000000000 Z
+date: 2021-10-22 00:00:00.000000000 Z
 dependencies: []
 description: Logging, easier, more consistent.
 email:
@@ -25,11 +25,10 @@ files:
 - docs/global-context.md
 - docs/syslog.md
 - lib/scrolls.rb
-- lib/scrolls/iolog.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
@@ -51,12 +50,11 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 3.2.29
 signing_key: 
 specification_version: 4
 summary: When do we log? All the time.

data/lib/scrolls/log.rb

@@ -1,262 +0,0 @@
-require "scrolls/parser"
-require "scrolls/utils"
-require "scrolls/iolog"
-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 sync_stream(out = STDOUT)
-      IOLog.new(out)
-    end
-
-    def write(data)
-      if log_level_ok?(data[:level])
-        msg = unparse(data)
-        stream.log(msg)
-      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

data/lib/scrolls/syslog.rb

@@ -1,46 +0,0 @@
-require 'syslog'
-
-module Scrolls
-
-  LOG_FACILITY = ENV['LOG_FACILITY'] || Syslog::LOG_USER
-  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,
-  }
-
-  class SyslogLogger
-    def initialize(ident = 'scrolls', facility = Syslog::LOG_USER)
-      options = Syslog::LOG_PID|Syslog::LOG_CONS
-      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
-
-    def self.opened?
-      Syslog.opened?
-    end
-  end
-end