scrolls 0.1.0 → 0.2.1

data/README.md

@@ -1,8 +1,10 @@
 # Scrolls
 
-Logging gem, compiled from many different internal projects in order to make
-it easier to add logging to projects. Basically I grew tired of moving this
-file around.
+Scrolls is a logging library that is focused on outputting logs in a
+key=value structure. It's in use at Heroku where we use the event data
+to drive metrics and monitoring services.
+
+Scrolls is rather opinionated.
 
 ## Installation
 
@@ -20,31 +22,123 @@ Or install it yourself as:
 
 ## Usage
 
-It's pretty easy to use:
+At Heroku we are big believers in "logs as data". We log everything so
+that we can act upon that event stream of logs. Internally we use logs
+to produce metrics and monitoring data that we can alert on.
+
+Here's an example of a log you might specify in your application:
+
+```ruby
+Scrolls.log(fn: "trap", signal: s, at: "exit", status: 0)
+```
+
+The output of which might be:
+
+    fn=trap signal=TERM at=exit status=0
+
+This provides a rich set of data that we can parse and act upon.
+
+A feature of Scrolls is setting contexts. Scrolls has two types of
+context. One is 'global_context' that prepends every log in your
+application with that data and a local 'context' which can be used,
+for example, to wrap requests with a request id.
+
+In our example above, the log message is rather generic, so in order
+to provide more context we might set a global context that links this
+log data to our application and deployment:
+
+```ruby
+Scrolls.global_context(app: "myapp", deploy: ENV["DEPLOY"])
+```
+
+This would change our log output above to:
+
+    app=myapp deploy=production fn=trap signal=TERM at=exit status=0
+
+If we were in a file and wanted to wrap a particular point of context
+we might also do something similar to:
+
+```ruby
+Scrolls.context(ns: "server") do
+  Scrolls.log(fn: "trap", signal: s, at: "exit", status: 0)
+end
+```
+
+This would be the output (taking into consideration our global context
+above):
 
-    require 'scrolls'
+    app=myapp deploy=production ns=server fn=trap signal=TERM at=exit status=0
 
-Put this somewhere early on in your application:
+This allows us to track this log to `Server#trap` and we received a
+'TERM' signal and exited 0.
 
-    Scrolls::Log.start
+As you can see we have some standard nomenclature around logging.
+Here's a cheat sheet for some of the methods we use:
 
-Use it:
+* `app`: Application
+* `lib`: Library
+* `ns`: Namespace (Class, Module or files)
+* `fn`: Function
+* `at`: Execution point
+* `deploy`: Our deployment (typically an environment variable i.e. `DEPLOY=staging`)
+* `elapsed`: Measurements (Time)
+* `count`: Measurements (Counters)
 
-    Scrolls.log(:testing => true, :at => "readme")
+Scrolls makes it easy to measure the run time of a portion of code.
+For example:
+
+```ruby
+    Scrolls.log(fn: "test") do
+      Scrolls.log(status: "exec")
+      # Code here
+    end
+```
+
+This will output the following log:
+
+    fn=test at=start
+    status=exec
+    fn=test at=finish elapsed=0.300
+
+You can change the time unit that Scrolls uses to "milliseconds" (the
+default is "seconds"):
+
+```ruby
+    Scrolls.time_unit = "ms"
+```
+
+Scrolls has a rich #parse method to handle a number of cases. Here is
+a look at some of the ways Scrolls handles certain values.
+
+Time and nil:
+
+```ruby
+    Scrolls.log(t: Time.at(1340118167), this: nil)
+    t=t=2012-06-19T11:02:35-0400 this=nil
+```
+
+True/False:
+
+```ruby
+    Scrolls.log(that: false, this: true)
+    that=false this=true
+```
+
+## History
+
+This library originated from various logging methods used internally
+at Heroku. Starting at version 0.2.0 Scrolls was ripped apart and
+restructured to provide a better foundation for the future. Tests and
+documentation were add at that point as well.
 
 ## Thanks
 
-I only compiled this library, many others made it work. Here are some of the
-authors of projects that I've used to get an idea of a consistent log gem:
+Most of the ideas used in Scrolls are those of other engineers at
+Heroku, I simply ripped them off to create a single library. Huge
+thanks to:
 
 * Mark McGranaghan
 * Noah Zoschke
 * Mark Fine
-
-## Contributing
-
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Added some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+* Fabio Kung
+* Ryan Smith

data/Rakefile

@@ -1,6 +1,8 @@
 #!/usr/bin/env rake
 require "bundler/gem_tasks"
 
+ENV['TESTOPTS'] = "-v"
+
 require "rake/testtask"
 Rake::TestTask.new do |t|
   t.pattern = "test/test_*.rb"

data/lib/scrolls/atomic.rb

@@ -0,0 +1,58 @@
+# 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
+
+require 'thread'
+
+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

data/lib/scrolls/log.rb

@@ -0,0 +1,196 @@
+require "scrolls/parser"
+require "scrolls/utils"
+
+module Scrolls
+
+  class TimeUnitError < RuntimeError; end
+
+  module Log
+    extend self
+
+    extend Parser
+    extend Utils
+
+    LOG_LEVEL = (ENV['LOG_LEVEL'] || 3).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 stream=(out=nil)
+      @defined = out.nil? ? false : true
+
+      @stream = sync_stream(out)
+    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 log(data, &blk)
+      if gc = get_global_context
+        ctx = gc.merge(context)
+        logdata = ctx.merge(data)
+      end
+
+      unless blk
+        write(logdata)
+      else
+        start = Time.now
+        res = nil
+        log(logdata.merge(at: "start"))
+        begin
+          res = yield
+        rescue StandardError, Timeout::Error => e
+          log(
+            :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 gc = get_global_context
+        logdata = gc.merge(data)
+      end
+
+      log(logdata.merge(
+          :at => "exception",
+          :class        => e.class,
+          :message      => e.message,
+          :exception_id => e.object_id.abs
+      ))
+      if e.backtrace
+        bt = e.backtrace.reverse
+        bt[0, bt.size-6].each do |line|
+          log(logdata.merge(
+              :at => "exception",
+              :class => e.message,
+              :exception_id => e.object_id.abs,
+              :site => line.gsub(/[`'"]/, "")
+          ))
+        end
+      end
+    end
+
+    def with_context(prefix)
+      return unless block_given?
+      old = context
+      self.context = old.merge(prefix)
+      yield if block_given?
+      self.context = old
+    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
+
+  end
+end

data/lib/scrolls/parser.rb

@@ -0,0 +1,64 @@
+module Scrolls
+  module Parser
+    extend self
+
+    def unparse(data)
+      data.map do |(k,v)|
+        if (v == true)
+          "#{k}=true"
+        elsif (v == false)
+          "#{k}=false"
+        elsif v.is_a?(Float)
+          "#{k}=#{format("%.3f", v)}"
+        elsif v.nil?
+          "#{k}=nil"
+        elsif v.is_a?(Time)
+          "#{k}=#{Time.at(v).strftime("%FT%H:%M:%S%z")}"
+        elsif v.is_a?(String) && v =~ /\\|\"| /
+          v = v.gsub(/\\|"/) { |c| "\\#{c}" }
+          "#{k}=\"#{v}\""
+        else
+          "#{k}=#{v}"
+        end
+      end.compact.join(" ")
+    end
+
+    def parse(data)
+      vals = {}
+      str = data.dup if data.is_a?(String)
+
+      patterns = [
+        /([^= ]+)="([^"\\]*(\\.[^"\\]*)*)"/, # key="\"literal\" escaped val"
+        /([^= ]+)=([^ =]+)/                  # key=value
+      ]
+
+      patterns.each do |pattern|
+        str.scan(pattern) do |match|
+          v = match[1]
+          v.gsub!(/\\"/, '"')                # unescape \"
+          v.gsub!(/\\\\/, "\\")              # unescape \\
+
+          if v.to_i.to_s == v                # cast value to int or float
+            v = v.to_i
+          elsif format("%.3f", v.to_f) == v
+            v = v.to_f
+          elsif v == "false"
+            v = false
+          elsif v == "true"
+            v = true
+          end
+
+          vals[match[0]] = v
+        end
+        # sub value, leaving keys in order
+        str.gsub!(pattern, "\\1")
+      end
+
+      # rebuild in-order key: value hash
+      str.split.inject({}) do |h,k|
+        h[k.to_sym] = vals[k]
+        h
+      end
+    end
+  end
+end

data/lib/scrolls/utils.rb

@@ -0,0 +1,21 @@
+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
+
+    def hashified_list(l)
+      return {} if l.empty?
+      l.inject({}) do |h, i|
+        h[i.to_sym] = true
+        h
+      end
+    end
+
+  end
+end

data/lib/scrolls/version.rb

@@ -1,3 +1,3 @@
 module Scrolls
-  VERSION = "0.1.0"
+  VERSION = "0.2.1"
 end

data/lib/scrolls.rb

@@ -1,172 +1,117 @@
 require "thread"
-require "atomic"
-
+require "scrolls/atomic"
+require "scrolls/log"
 require "scrolls/version"
 
 module Scrolls
   extend self
 
+  # Public: Set a context in a block for logs
+  #
+  # data - A hash of key/values to prepend to each log in a block
+  # blk  - The block that our context wraps
+  #
+  # Examples:
+  #
+  def context(data, &blk)
+    Log.with_context(data, &blk)
+  end
+
+  # Public: Get or set a global context that prefixs all logs
+  #
+  # data - A hash of key/values to prepend to each log
+  #
+  def global_context(data=nil)
+    if data
+      Log.global_context = data
+    else
+      Log.global_context
+    end
+  end
+
+  # Public: Log data and/or wrap a block with start/finish
+  #
+  # data - A hash of key/values to log
+  # blk  - A block to be wrapped by log lines
+  #
+  # Examples:
+  #
+  #   Scrolls.log(test: "test")
+  #   test=test
+  #   => nil
+  #
+  #   Scrolls.log(test: "test") { puts "inner block" }
+  #   at=start
+  #   inner block
+  #   at=finish elapsed=0.000
+  #   => nil
+  #
   def log(data, &blk)
     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
+  #
+  # Examples:
+  #
+  #   begin
+  #     raise Exception
+  #   rescue Exception => e
+  #     Scrolls.log_exception({test: "test"}, e)
+  #   end
+  #   test=test at=exception class=Exception message=Exception exception_id=70321999017240
+  #   ...
+  #
   def log_exception(data, e)
     Log.log_exception(data, e)
   end
 
-  def global_context(data)
-    Log.global_context = data
+  # Public: Setup a new output (default: STDOUT)
+  #
+  # out - New output
+  #
+  # Examples
+  #
+  #   Scrolls.stream = StringIO.new
+  #
+  def stream=(out)
+    Log.stream=(out)
   end
 
-  def context(data, &blk)
-    Log.with_context(data, &blk)
+  # Public: Return the stream
+  #
+  # Examples
+  #
+  #   Scrolls.stream
+  #   => #<IO:<STDOUT>>
+  #
+  def stream
+    Log.stream
   end
 
-  module Log
-    extend self
-
-    LOG_LEVEL = (ENV["LOG_LEVEL"] || 3).to_i
-
-    #http://tools.ietf.org/html/rfc5424#page-11
-    LOG_LEVEL_MAP = {
-      "emergency" => 0,
-      "alert"     => 1,
-      "critical"  => 2,
-      "error"     => 3,
-      "warning"   => 4,
-      "notice"    => 5,
-      "info"      => 6,
-      "debug"     => 7
-    }
-
-    attr_accessor :stream
-
-    def context
-      Thread.current[:scrolls_context] ||= {}
-    end
-
-    def context=(hash)
-      Thread.current[:scrolls_context] = hash
-    end
-
-    def start(out = nil)
-      # This allows log_exceptions below to pick up the defined output,
-      # otherwise stream out to STDERR
-      @defined = out.nil? ? false : true
-
-      sync_stream(out)
-      @global_context = Atomic.new({})
-    end
-
-    def sync_stream(out = nil)
-      out = STDOUT if out.nil?
-      @stream = out
-      @stream.sync = true
-    end
-
-    def mtx
-      @mtx ||= Mutex.new
-    end
-
-    def write(data)
-      if log_level_ok?(data[:level])
-        msg = unparse(data)
-        mtx.synchronize do
-          begin
-            @stream.puts(msg)
-          rescue NoMethodError => e
-            puts "You need to start your logger, `Scrolls::Log.start`"
-          end
-        end
-      end
-    end
-
-    def unparse(data)
-      data.map do |(k, v)|
-        if (v == true)
-          k.to_s
-        elsif v.is_a?(Float)
-          "#{k}=#{format("%.3f", v)}"
-        elsif v.nil?
-          nil
-        else
-          v_str = v.to_s
-          if (v_str =~ /^[a-zA-z0-9\-\_\.]+$/)
-            "#{k}=#{v_str}"
-          else
-            "#{k}=\"#{v_str.sub(/".*/, "...")}\""
-          end
-        end
-      end.compact.join(" ")
-    end
-
-    def log(data, &blk)
-      merged_context = @global_context.value.merge(context)
-      logdata = merged_context.merge(data)
-
-      unless blk
-        write(logdata)
-      else
-        start = Time.now
-        res = nil
-        log(logdata.merge(:at => :start))
-        begin
-          res = yield
-        rescue StandardError, Timeout::Error => e
-          log(logdata.merge(
-            :at           => :exception,
-            :reraise      => true,
-            :class        => e.class,
-            :message      => e.message,
-            :exception_id => e.object_id.abs,
-            :elapsed      => Time.now - start
-          ))
-          raise(e)
-        end
-        log(logdata.merge(:at => :finish, :elapsed => Time.now - start))
-        res
-      end
-    end
-
-    def log_exception(data, e)
-      sync_stream(STDERR) unless @defined
-      log(data.merge(
-        :exception    => true,
-        :class        => e.class,
-        :message      => e.message,
-        :exception_id => e.object_id.abs
-      ))
-      if e.backtrace
-        bt = e.backtrace.reverse
-        bt[0, bt.size-6].each do |line|
-          log(data.merge(
-            :exception    => true,
-            :exception_id => e.object_id.abs,
-            :site         => line.gsub(/[`'"]/, "")
-          ))
-        end
-      end
-    end
-
-    def log_level_ok?(level)
-      if level
-        LOG_LEVEL_MAP[level.to_s] <= LOG_LEVEL
-      else
-        true
-      end
-    end
-
-    def with_context(prefix)
-      return unless block_given?
-      old_context = context
-      self.context = old_context.merge(prefix)
-      yield if block_given?
-      self.context = old_context
-    end
-
-    def global_context=(data)
-      @global_context.update { |_| data }
-    end
+  # Public: Set the time unit we use for 'elapsed' (default: "seconds")
+  #
+  # unit - The time unit ("milliseconds" currently supported)
+  #
+  # Examples
+  #
+  #   Scrolls.time_unit = "milliseconds"
+  #
+  def time_unit=(unit)
+    Log.time_unit=(unit)
+  end
 
+  # Public: Return the time unit currently configured
+  #
+  # Examples
+  #
+  #   Scrolls.time_unit
+  #   => "seconds"
+  #
+  def time_unit
+    Log.time_unit
   end
 end

data/scrolls.gemspec

@@ -2,16 +2,16 @@
 require File.expand_path('../lib/scrolls/version', __FILE__)
 
 Gem::Specification.new do |gem|
-  gem.authors       = ["Heroku"]
-  gem.email         = ["curt@heroku.com"]
-  gem.description   = "Logging, easier, more consistent."
-  gem.summary       = "When do we log? All the time."
+  gem.authors       = ["Curt Micol"]
+  gem.email         = ["asenchi@asenchi.com"]
+  gem.description   = %q{Logging, easier, more consistent.}
+  gem.summary       = %q{When do we log? All the time.}
   gem.homepage      = "https://github.com/asenchi/scrolls"
-  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  gem.files         = `git ls-files`.split("\n")
-  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.name          = "scrolls"
   gem.require_paths = ["lib"]
   gem.version       = Scrolls::VERSION
-  gem.add_dependency("atomic", "~> 1.0.0")
 end

data/test/test_atomic.rb

@@ -0,0 +1,33 @@
+require_relative "test_helper"
+
+class TestAtomic < Test::Unit::TestCase
+  def test_construct
+    atomic = Atomic.new
+    assert_equal nil, atomic.value
+    
+    atomic = Atomic.new(0)
+    assert_equal 0, atomic.value
+  end
+  
+  def test_value
+    atomic = Atomic.new(0)
+    atomic.value = 1
+    
+    assert_equal 1, atomic.value
+  end
+  
+  def test_update
+    atomic = Atomic.new(1000)
+    res = atomic.update {|v| v + 1}
+    
+    assert_equal 1001, atomic.value
+    assert_equal 1001, res
+  end
+
+  def test_update_retries
+    tries = 0
+    atomic = Atomic.new(1000)
+    atomic.update{|v| tries += 1 ; atomic.value = 1001 ; v + 1}
+    assert_equal 2, tries
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+require "test/unit"
+require "stringio"
+
+$: << File.expand_path("../../lib", __FILE__)
+
+require "scrolls"

data/test/test_parser.rb

@@ -0,0 +1,52 @@
+require_relative "test_helper"
+
+class TestScrollsParser < Test::Unit::TestCase
+  include Scrolls::Parser
+  
+  def test_parse_bool
+    data = { test: true, exec: false }
+    assert_equal "test=true exec=false", unparse(data)
+    assert_equal data.inspect, parse(unparse(data)).inspect
+  end
+
+  def test_parse_numbers
+    data = { elapsed: 12.00000, __time: 0 }
+    assert_equal "elapsed=12.000 __time=0", unparse(data)
+    assert_equal data.inspect, parse(unparse(data)).inspect
+  end
+
+  def test_parse_strings
+    # Strings are all double quoted, with " or \ escaped
+    data = { s: "echo 'hello' \"world\"" }
+    assert_equal 's="echo \'hello\' \\"world\\""', unparse(data)
+    assert_equal data.inspect, parse(unparse(data)).inspect
+
+    data = { s: "hello world" }
+    assert_equal 's="hello world"', unparse(data)
+    assert_equal data.inspect, parse(unparse(data)).inspect
+
+    data = { s: "slasher\\" }
+    assert_equal 's="slasher\\\\"', unparse(data)
+    assert_equal data.inspect, parse(unparse(data)).inspect
+
+    # simple value is unquoted
+    data = { s: "hi" }
+    assert_equal 's=hi', unparse(data)
+    assert_equal data.inspect, parse(unparse(data)).inspect
+  end
+
+  def test_parse_constants
+    data = { s1: :symbol, s2: Scrolls }
+    assert_equal "s1=symbol s2=Scrolls", unparse(data)
+  end
+
+  def test_parse_time
+    data = { t: Time.at(1340118155) }
+    assert_equal "t=2012-06-19T11:02:35-0400", unparse(data)
+  end
+
+  def test_parse_nil
+    data = { n: nil }
+    assert_equal "n=nil", unparse(data)
+  end
+end

data/test/test_scrolls.rb

@@ -1,31 +1,110 @@
-require "stringio"
-require "minitest/autorun"
+require_relative "test_helper"
 
-$: << "../lib"
-require "scrolls"
+class TestScrolls < Test::Unit::TestCase
+  def setup
+    @out = StringIO.new
+    Scrolls.stream = @out
+  end
+
+  def teardown
+    Scrolls.global_context({})
+  end
+
+  def test_construct
+    assert_equal StringIO, Scrolls.stream.class
+  end
+
+  def test_default_global_context
+    assert_equal Hash.new, Scrolls.global_context
+  end
+
+  def test_setting_global_context
+    Scrolls.global_context(g: "g")
+    Scrolls.log(d: "d")
+    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
+  end
 
-class TestScrollsParser < MiniTest::Unit::TestCase
-  def test_unparse_tags
-    data = {:test => true, :tag => true}
-    assert "test tag" == Scrolls::Log.unparse(data)
+  def test_setting_context
+    Scrolls.context(c: "c") { Scrolls.log(i: "i") }
+    output = "c=c i=i\n"
+    assert_equal output, @out.string
   end
 
-  def test_unparse_strings
-    data = {:test => "strings"}
-    assert "test=strings" == Scrolls::Log.unparse(data)
+  def test_all_the_contexts
+    Scrolls.global_context(g: "g")
+    Scrolls.log(o: "o") do
+      Scrolls.context(c: "c") do
+        Scrolls.log(ic: "i")
+      end
+      Scrolls.log(i: "i")
+    end
+    @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
+    Scrolls.log(o: "o") do
+      Scrolls.context(c: "c") do
+        Scrolls.log(ic: "i")
+      end
+      Scrolls.log(i: "i")
+    end
+    @out.truncate(21)
+    output = "o=o at=start\nc=c ic=i"
+    assert_equal output, @out.string
+  end
 
-    data = {:s => "echo 'hello' \"world\""}
-    assert 's="echo \'hello\' ..."' == Scrolls::Log.unparse(data)
+  def test_deeply_nested_context_dropped
+    Scrolls.log(o: "o") do
+      Scrolls.context(c: "c") do
+        Scrolls.log(ic: "i")
+      end
+      Scrolls.log(i: "i")
+    end
+    @out.truncate(25)
+    output = "o=o at=start\nc=c ic=i\ni=i"
+    assert_equal output, @out.string
+  end
+
+  def test_default_time_unit
+    assert_equal "seconds", Scrolls.time_unit
+  end
 
-    data = {:s => "hello world"}
-    assert 's="hello world"' == Scrolls::Log.unparse(data)
+  def test_setting_time_unit
+    Scrolls.time_unit = "milliseconds"
+    assert_equal "milliseconds", Scrolls.time_unit
+  end
+
+  def test_setting_incorrect_time_unit
+    assert_raise Scrolls::TimeUnitError do
+      Scrolls.time_unit = "years"
+    end
+  end
+
+  def test_logging
+    Scrolls.log(test: "basic")
+    assert_equal "test=basic\n", @out.string
+  end
 
-    data = {:s => "hello world\\"}
-    assert 's="hello world\"' == Scrolls::Log.unparse(data)
+  def test_logging_block
+    Scrolls.log(outer: "o") { Scrolls.log(inner: "i") }
+    output = "outer=o at=start\ninner=i\nouter=o at=finish elapsed=0.000\n"
+    assert_equal output, @out.string
   end
 
-  def test_unparse_floats
-    data = {:test => 0.3}
-    assert "test=0.300" == Scrolls::Log.unparse(data)
+  def test_log_exception
+    begin
+      raise Exception
+    rescue Exception => e
+      Scrolls.log_exception({test: "exception"}, e)
+    end
+    @out.truncate(27)
+    assert_equal "test=exception at=exception", @out.string
   end
 end

metadata

@@ -1,30 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: scrolls
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
   prerelease: 
 platform: ruby
 authors:
-- Heroku
+- Curt Micol
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-26 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: atomic
-  requirement: &70343059161980 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 1.0.0
-  type: :runtime
-  prerelease: false
-  version_requirements: *70343059161980
+date: 2012-06-20 00:00:00.000000000 Z
+dependencies: []
 description: Logging, easier, more consistent.
 email:
-- curt@heroku.com
+- asenchi@asenchi.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -35,8 +24,15 @@ files:
 - README.md
 - Rakefile
 - lib/scrolls.rb
+- lib/scrolls/atomic.rb
+- lib/scrolls/log.rb
+- lib/scrolls/parser.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
 homepage: https://github.com/asenchi/scrolls
 licenses: []
@@ -63,4 +59,7 @@ signing_key:
 specification_version: 3
 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