batlog 0.9

data/.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require "./lib/log/version"
+
+Gem::Specification.new do |s|
+  s.name        = 'batlog'
+  s.version     = Log::VERSION
+  s.homepage    = "https://github.com/TheGiftsProject/batlog"
+  s.summary     = "A structured logging system"
+  s.authors      = ["Asaf Gartner", "Yonatan Bergman"]
+  s.email       = 'agartner@ebay.com'
+  s.platform    = Gem::Platform::RUBY
+
+  s.files       = `git ls-files`.split("\n")
+  s.require_path = "lib"
+
+  s.add_dependency "rails"
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+
+  s.test_files = Dir.glob('spec/lib/*_spec.rb')
+
+  s.post_install_message = "Run 'rails generate db_log' and then migrate to start using the log with database backend"
+end

data/.gitignore

@@ -0,0 +1 @@
+.idea

data/.rspec

@@ -0,0 +1 @@
+--colour --format documentation

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.8.7@log --create

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 1.8.7

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,102 @@
+PATH
+  remote: .
+  specs:
+    batlog (0.9)
+      rails
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    actionmailer (3.2.8)
+      actionpack (= 3.2.8)
+      mail (~> 2.4.4)
+    actionpack (3.2.8)
+      activemodel (= 3.2.8)
+      activesupport (= 3.2.8)
+      builder (~> 3.0.0)
+      erubis (~> 2.7.0)
+      journey (~> 1.0.4)
+      rack (~> 1.4.0)
+      rack-cache (~> 1.2)
+      rack-test (~> 0.6.1)
+      sprockets (~> 2.1.3)
+    activemodel (3.2.8)
+      activesupport (= 3.2.8)
+      builder (~> 3.0.0)
+    activerecord (3.2.8)
+      activemodel (= 3.2.8)
+      activesupport (= 3.2.8)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activeresource (3.2.8)
+      activemodel (= 3.2.8)
+      activesupport (= 3.2.8)
+    activesupport (3.2.8)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    arel (3.0.2)
+    builder (3.0.4)
+    diff-lcs (1.1.3)
+    erubis (2.7.0)
+    hike (1.2.1)
+    i18n (0.6.1)
+    journey (1.0.4)
+    json (1.7.5)
+    mail (2.4.4)
+      i18n (>= 0.4.0)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    mime-types (1.19)
+    multi_json (1.3.6)
+    polyglot (0.3.3)
+    rack (1.4.1)
+    rack-cache (1.2)
+      rack (>= 0.4)
+    rack-ssl (1.3.2)
+      rack
+    rack-test (0.6.2)
+      rack (>= 1.0)
+    rails (3.2.8)
+      actionmailer (= 3.2.8)
+      actionpack (= 3.2.8)
+      activerecord (= 3.2.8)
+      activeresource (= 3.2.8)
+      activesupport (= 3.2.8)
+      bundler (~> 1.0)
+      railties (= 3.2.8)
+    railties (3.2.8)
+      actionpack (= 3.2.8)
+      activesupport (= 3.2.8)
+      rack-ssl (~> 1.3.2)
+      rake (>= 0.8.7)
+      rdoc (~> 3.4)
+      thor (>= 0.14.6, < 2.0)
+    rake (0.9.2.2)
+    rdoc (3.12)
+      json (~> 1.4)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.3)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.3)
+    sprockets (2.1.3)
+      hike (~> 1.2)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    thor (0.16.0)
+    tilt (1.3.3)
+    treetop (1.4.11)
+      polyglot
+      polyglot (>= 0.3.1)
+    tzinfo (0.3.33)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  batlog!
+  rake
+  rspec

data/README.md

@@ -0,0 +1,112 @@
+# BatLog v0.9
+![batlog-logo](https://dl.dropbox.com/u/7525692/batlog-withtext.png "BatLog")
+
+## Setup
+To install BatLog into your Rails app just run `rails generate db_log` to create the db_log's table migration.
+By default BatLog writes to three places - the database, the rails logger and exceptions to exceptional
+You can overide this behaivour by providing your own loggers or changing the default logger in the configuration.
+
+The cool thing about BatLog is that it adds the concept of `context` - your logs aren't one time message left by a deity but
+ are part of a flow of a user in specific system and circumstance. BatLog lets you collect a context for the current Thread
+ and dump it as part of the BatLog whenever needed be it in Exception and be it in debug prints.
+
+## Usage
+### Logging
+```ruby
+Log.debug(message, context)
+Log.info(message, context)
+Log.warn(message, context)
+Log.error(message, context)
+Log.fatal(message, context)
+```
+Use these to record logs. The method indicates the severity.
+* `message` - The message to record to log. Can be of the following types:
+  * `String` - Will be used as-is.
+  * `Exception` - Message will be extracted from exception.
+  * `Log::LoggableError` - Message will be extracted from exception and data will be merged into context
+* `context` - `Hash`. Extra data that's related to the message.
+
+### Events
+Events are kept in memory (until clear_events is called or the thread exits) and 
+are only written when one of the above log methods is called.
+
+```ruby
+Log.event(name, data)
+```
+Adds an event to `Log`'s internal event array.
+* `name` - `String`. The name of the event.
+* `data` - `Hash`. Extra data that's related to the event.
+
+```ruby
+Log.clear_events
+```
+Empties the list of events.
+
+### Asserts
+```ruby
+Log.assert(condition, message, context, options)
+```
+* `condition` - `Boolean`. Indicates whether the condition you were testing succeeded. When `false` - triggers a log.
+* `message` - Same as in the logging methods.
+* `context` - Same as in the logging methods.
+* `options` - `Hash`. Includes the following:
+  * `severity` - `Symbol`. The severity to use for logging when the condition fails. (Default: `:error`)
+  * `raise_error` - `Boolean`. Indicates whether the assert should raise an error if condition fails. (Default: `false`)
+
+### Configuring `Log`
+To configure Log just create an initializer `config/initializers/log.rb`
+There you can set the configuration of the log system.
+```ruby
+Log.config.loggers << MyCustomLogger
+# or
+Log.config.loggers = [MyCustomLogger]
+```
+`Log.config.loggers` is an array of the loggers that will be called by the log dispatch each time you write a log.
+They will be called in the order they appear in the array.
+Default: `[DBlogger, RailsLogger, ExceptionalLogger]`
+
+```ruby
+Log.config,raise_on_failed_asserts = false #boolean
+```
+Set to `true` if you want all asserts to raise an exception when they fail. Useful
+when developing and testing.
+Default: `false`
+
+```ruby
+Log.config,raise_on_log_failure = false #boolean
+```
+Set to true if you want to raise an exception when one of the loggers raises an
+exception.
+If this is `false`, `Log` will only try to log the failure using the loggers that
+didn't fail.
+Default: `false`
+
+### Creating a custom logger
+A logger object needs to implement the following interface:
+```ruby
+class YourLogger
+  def self.log(severity, message, context, events, metadata)
+    # record stuff here
+  end
+end
+```
+
+* `severity` - `Symbol`. The log level. One of the following: `debug`, `info`, `warn`, `error`, `fatal`
+* `message` - `String`.
+* `context` - `Hash`. Extra data that's related to the message.
+* `events` - `Array`. A collection of all recorded events prior to the log call. (contents of the array covered in later section)
+* `metadata` - `Hash`. Extra data related to the logging process, added by other loggers that ran prior to this one.
+
+If your log method returns a `Hash`, it will be merged into metadata and sent to
+all subsequent loggers.
+
+
+### Controller Support
+Also included with BatLog is the log controller support to use it we recommend you add it to your ApplicationController
+by adding these lines to it.
+```ruby
+require 'log/controller_support'
+
+include Log::ControllerSupport
+```
+This does two things, first it adds a before_filter that captures as much data as it can into the log.context and also hooks for when a CSRF exception occurs

data/Rakefile

@@ -0,0 +1,3 @@
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new('spec')
+task :default => :spec

data/app/models/log/db_log.rb

@@ -0,0 +1,9 @@
+module Log
+  class DbLog < ActiveRecord::Base
+    self.table_name = :logs
+    attr_accessible :severity, :message, :context
+
+    store :context, :accessors => [:environment]
+
+  end
+end

data/lib/batlog.rb

@@ -0,0 +1,5 @@
+require 'log/log'
+require "log/engine"
+
+module Log
+end

data/lib/log/config.rb

@@ -0,0 +1,35 @@
+require 'loggers/database_logger'
+require 'loggers/rails_logger'
+
+module Log
+  class Config
+
+    attr_accessor :raise_on_log_failure, :raise_on_failed_asserts, :loggers
+
+    def self.default
+      new.instance_eval {
+        @raise_on_log_failure = false
+        @raise_on_failed_asserts = false
+        @loggers = default_loggers
+
+        self
+      }
+    end
+
+    def default_loggers
+      loggers = []
+
+      loggers << DatabaseLogger
+      loggers << RailsLogger
+
+      if defined?(Exceptional)
+        require 'loggers/exceptional_logger'
+        loggers << ExceptionalLogger
+      end
+
+      loggers
+
+    end
+
+  end
+end

data/lib/log/controller_support.rb

@@ -0,0 +1,43 @@
+require 'active_support/concern'
+
+module Log
+  module ControllerSupport
+
+    extend ActiveSupport::Concern
+
+    included do
+      before_filter :set_log_context if respond_to? :before_filter
+      after_filter  :clear_log_context if respond_to? :after_filter
+      alias_method_chain :handle_unverified_request, :log
+    end
+
+    def set_log_context
+      context = {}
+      context.merge!(
+          :url => request.url,
+          :user_agent => request.user_agent,
+          :ip => request.ip,
+          :remote_ip => request.remote_ip,
+          :referer => request.referer,
+          :environment => Rails.env.to_s,
+          :session_id => request.session_options[:id],
+          :session => session,
+          :params => params
+      )
+      context.merge!(:current_user => current_user.try(:id)) if respond_to? :current_user
+      context.merge!(more_context) if respond_to? :more_context
+      Log.clear_context
+      Log.context(context)
+    end
+
+    def clear_log_context
+      Log.clear_context
+    end
+
+    def handle_unverified_request_with_log
+      Log.warn("Can't verify CSRF token authenticity")
+      handle_unverified_request_without_log
+    end
+
+  end
+end

data/lib/log/dispatcher.rb

@@ -0,0 +1,57 @@
+require 'log/loggable_error'
+
+module Log
+  class Dispatcher
+    attr_accessor :raise_on_log_failure
+
+    def self.dispatch(severity, message, context = {}, events = [])
+      Dispatcher.new(Log.config.loggers).dispatch(severity, message, context, events)
+    end
+
+    def initialize(loggers)
+      Dispatcher.verify_loggers(config.loggers)
+      @loggers = loggers
+    end
+
+    def dispatch(severity, message, context={}, events=[])
+      raise ArgumentError.new("context must be Hash") unless context.kind_of?(Hash)
+
+      failed_loggers = {}
+      metadata = {}
+      @loggers.each do |logger|
+        begin
+          result = logger.log(severity, message, context, events, metadata)
+          metadata.merge!(result) if (result.kind_of?(Hash))
+        rescue => e
+          failed_loggers[logger.name] = e
+        end
+      end
+
+      handle_failed_loggers(failed_loggers)
+    end
+
+    private
+
+    def config
+      Log.config
+    end
+
+    def self.verify_loggers(loggers)
+      raise ArgumentError.new("Dispatcher requires an array of loggers") if (!loggers.kind_of?(Array))
+
+      loggers.each do |logger|
+        raise ArgumentError.new("Logger #{logger.name} doesn't implement self.log") if (!logger.respond_to?(:log))
+      end
+    end
+
+    def handle_failed_loggers(failed_loggers)
+      unless failed_loggers.empty?
+        logger_errors = failed_loggers.map{ |logger_name, logger_error| { logger_name => logger_error.message } }
+        working_loggers = @loggers.reject{ |logger| failed_loggers.keys.include?(logger.name) }
+        Dispatcher.new(working_loggers).dispatch(:error, "Loggers failed", :logger_errors => logger_errors)
+        raise LoggableError.new("Loggers failed", { :logger_errors => logger_errors }) if config.raise_on_log_failure
+      end
+    end
+
+  end
+end

data/lib/log/engine.rb

@@ -0,0 +1,8 @@
+require "batlog"
+require 'rails'
+
+module Log
+  class Engine < ::Rails::Engine
+    #isolate_namespace Log
+  end
+end

data/lib/log/events.rb

@@ -0,0 +1,19 @@
+module Log
+  module Events
+    EVENTS_KEY = :log_events
+
+    def self.add(name, data)
+      Thread.current[EVENTS_KEY] = all.push({ :name => name, :data => data })
+      return self
+    end
+
+    def self.reset
+      Thread.current[EVENTS_KEY] = []
+      return self
+    end
+
+    def self.all
+      (Thread.current[EVENTS_KEY] || []).dup
+    end
+  end
+end

data/lib/log/log.rb

@@ -0,0 +1,80 @@
+require 'log/config'
+require 'log/dispatcher'
+require 'log/events'
+require 'log/loggable_error'
+require 'log/utils'
+
+module Log
+
+  SEVERITIES = {
+    :debug  => 0,
+    :info   => 1,
+    :warn   => 2,
+    :error  => 3,
+    :fatal  => 4
+  }
+
+  def self.config
+    @config ||= Log::Config.default
+  end
+
+  # This generates the following interface for each severity:
+  # log.{severity}(message, context=nil)
+  # i.e. log.info("hello", {:subsystem => :user, :action => "user creation"})
+  SEVERITIES.each_key do |severity|
+    (class << self; self; end).send(:define_method, severity.to_s) do |*args|
+      message, ctx = *args
+      ctx = context.merge(ctx)
+      self.write(severity, message, ctx)
+    end
+  end
+
+  def self.assert(condition, message, context = {}, severity=:error, raise_error=nil)
+    if condition
+      return true
+    else
+      assert_failed(severity, message, context, raise_error)
+      return false
+    end
+  end
+
+  def self.event(name, data={})
+    Events.add(name, data)
+  end
+
+  def self.clear_events
+    Events.reset
+  end
+
+  def self.context(hash = {})
+    Thread.current[:log_context] ||= {}
+    Thread.current[:log_context].merge!(hash)
+  end
+
+  def self.clear_context
+    Thread.current[:log_context] = nil
+  end
+
+  private
+
+  def self.write(severity, message, context)
+    context = {} if context.nil? # This is different from setting a default. If a user passes nil, it'll be converted to {}.
+    context = handle_loggable_error(message, context)
+    Dispatcher.dispatch(severity, message, context, Events.all)
+  end
+
+  def self.handle_loggable_error(message, context)
+    if message.kind_of?(LoggableError)
+      context.merge(:error_data => message.data)
+    else
+      context
+    end
+  end
+
+  def self.assert_failed(severity, message, context, raise_error)
+    write(severity, message, context)
+    return if raise_error == false #specific if raise_error is false but config is on
+    raise LoggableError.new(message, context) if (raise_error || config.raise_on_failed_asserts)
+  end
+
+end

data/lib/log/loggable_error.rb

@@ -0,0 +1,10 @@
+module Log
+  class LoggableError < StandardError
+    attr_accessor :data
+
+    def initialize(message=nil, data=nil)
+      super(message)
+      @data = data
+    end
+  end
+end

data/lib/log/utils.rb

@@ -0,0 +1,28 @@
+module Log
+  class Utils
+    def self.pretty_print_exception(exception)
+      raise ArgumentError.new("must pass exception") if (!exception.kind_of? Exception)
+
+      # Code taken from C:\Ruby192\lib\ruby\gems\1.9.1\gems\actionpack-3.0.3\lib\action_dispatch\middleware\show_exceptions.rb
+      message = "\n#{exception.class} (#{exception.message}):\n"
+      message << exception.annoted_source_code.to_s if exception.respond_to?(:annoted_source_code)
+      message << "  " << (defined?(Rails) && Rails.respond_to?(:backtrace_cleaner) && exception.backtrace ?
+            Rails.backtrace_cleaner.clean(exception.backtrace) :
+            exception.backtrace).try(:join, "\n  ").to_s
+
+      return message
+    end
+
+    def self.prepare_message(message, simple=false)
+      if message.kind_of? Exception
+        if simple
+          return message.message
+        else
+          return pretty_print_exception(message)
+        end
+      end
+
+      return message.to_s
+    end
+  end
+end

data/lib/log/version.rb

@@ -0,0 +1,3 @@
+module Log
+  VERSION = 0.9
+end

data/lib/loggers/database_logger.rb

@@ -0,0 +1,28 @@
+require 'log/utils'
+
+class DatabaseLogger
+  def self.log(severity, message, context, events, metadata)
+    log = nil
+    context = context.merge({ :metadata => metadata }) unless metadata.empty?
+    message = Log::Utils.prepare_message(message, true)
+    # In order to prevent logs from being deleted by a rollback, we need to create a new database connection (a new transaction doesn't work).
+    # The only way to create a new database connection is to open a new thread.
+    # Connection must be manually closed at the end of the thread. This only closes the thread's connection, not the main one.
+    Thread.new do
+      begin
+        log = create_log(severity, message, context, events)
+      ensure
+        ActiveRecord::Base.connection.close # must be done manually on new threads
+      end
+    end.join # we need the result of this operation before moving on.
+    return { :db_log_id => log.id }
+  end
+
+  private
+
+  def self.create_log(severity, message, context, events)
+    Log::DbLog.create!(:severity => severity.to_s,
+                       :message  => message,
+                       :context  => context)
+  end
+end

data/lib/loggers/exceptional_logger.rb

@@ -0,0 +1,19 @@
+require 'log/log'
+require 'exceptional'
+
+class ExceptionalLogger
+  class HandleMessageError < StandardError; end
+
+  def self.log(severity, message, context, events, metadata)
+    context = context.merge(:severity => severity.to_s, :events => events, :metadata => metadata)
+    if message.kind_of?(Exception)
+      Exceptional.context(context)
+      Exceptional.handle(message)
+      Exceptional.clear!
+    elsif Log::SEVERITIES[severity] >= Log::SEVERITIES[:error]
+      Exceptional.rescue(message, context) do
+        raise HandleMessageError.new(message)
+      end
+    end
+  end
+end

data/lib/loggers/rails_logger.rb

@@ -0,0 +1,49 @@
+require 'log/utils'
+
+class RailsLogger
+
+  NEW_LINE = "\r\n"
+
+  def self.log(severity, message, context, events, metadata)
+    text = build_log_text(severity, message, context, events, metadata)
+
+    logger = ::Rails.logger
+    begin
+      logger.send(severity.to_s, text)
+    rescue
+      logger.info(text) # chosen severity might not exist for file logger
+    end
+  end
+
+  private
+
+  def self.build_log_text(severity, message, context, events, metadata)
+    lines = []
+    lines.push("======= #{severity.to_s.capitalize} =======")
+    lines.push("## Message: #{Log::Utils.prepare_message(message)}")
+    lines.push("##")
+
+    lines.push("## Events:")
+    events.each do |event|
+      lines.push("##   #{event[:name]}: #{event[:data]}")
+    end
+    lines.push("##")
+
+    lines.push("## Context:")
+    context.each do |item|
+      lines.push("##   #{item[0]}: #{item[1].inspect}")
+    end
+    lines.push("##")
+
+    lines.push("## Metadata:")
+    metadata.each do |item|
+      lines.push("##   #{item[0]}: #{item[1].inspect}")
+    end
+
+    lines.push("========#{'=' * severity.to_s.length}========")
+
+    text = "#{NEW_LINE*2}"
+    text += "#{lines.join(NEW_LINE)}"
+    text += "#{NEW_LINE*2}"
+  end
+end

data/spec/lib/dispatcher_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+module Log
+  describe Dispatcher do
+    class Logger1
+      def self.meta_data
+        { :some => "Hash" }
+      end
+
+      def self.log(severity, message, context_data, events, metadata)
+        meta_data
+      end
+    end
+
+    class Logger2
+      def self.log(severity, message, context_data, events, metadata)
+      end
+    end
+
+    class BadLogger
+      def self.error_message
+        "Bad logger is bad"
+      end
+
+      def self.log(severity, message, context_data, events, metadata)
+        raise error_message
+      end
+    end
+
+    describe "dispatch" do
+
+      before do
+        Log.config.loggers = [Logger1, Logger2]
+      end
+
+      let (:severity) { :error }
+      let (:message) { "test message" }
+      let (:context_data) { { :a => 2 } }
+      let (:events) { [{ :name => "bla", :data => { :b => 3 } }] }
+
+      def dispatch
+        Dispatcher.dispatch(severity, message, context_data, events)
+      end
+
+      it "calls each logger's log method in order" do
+        Logger1.should_receive(:log).ordered
+        Logger2.should_receive(:log).ordered
+        dispatch
+      end
+
+      it "passes the severity to the logger" do
+        Logger1.should_receive(:log).with(severity, anything, anything, anything, anything)
+        dispatch
+      end
+
+      it "passes the message to the logger" do
+        Logger1.should_receive(:log).with(anything, message, anything, anything, anything)
+        dispatch
+      end
+
+      it "passes the context to the logger" do
+        Logger1.should_receive(:log).with(anything, anything, context_data, anything, anything)
+        dispatch
+      end
+
+      it "passes the events to the logger" do
+        Logger1.should_receive(:log).with(anything, anything, anything, events, anything)
+        dispatch
+      end
+
+      it "passes the metadata returned from previous loggers" do
+        Logger2.should_receive(:log).with(anything, anything, anything, anything, Logger1.meta_data)
+        dispatch
+      end
+
+      context "when logger failed" do
+
+        before do
+          Log.config.loggers << BadLogger
+        end
+
+        it "logs an error using the loggers that worked" do
+          Logger1.should_receive(:log).twice
+          Logger2.should_receive(:log).twice
+          BadLogger.should_receive(:log).once.and_raise("log error")
+          dispatch
+        end
+
+        context "when set to raise error on log failure" do
+          before do
+            Log.config.raise_on_log_failure = true
+          end
+
+          it "raises an error" do
+            BadLogger.should_receive(:log).and_raise("log error")
+            expect {
+              dispatch
+            }.to raise_error
+          end
+        end
+      end
+    end
+  end
+
+end

data/spec/lib/events_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Log::Events do
+  let(:test_name) { "Test name" }
+  let(:test_data) { { :a => 5 } }
+
+  it "adds new event to the events array" do
+    subject.add(test_name, test_data)
+    subject.all.last.should == { :name => test_name, :data => test_data }
+  end
+
+  it "clears the events array" do
+    subject.add(test_name, test_data)
+    subject.reset
+    subject.all.should == []
+  end
+
+  it "returns the whole events array" do
+    subject.add(test_name, test_data)
+    subject.add(test_name, test_data)
+    subject.add(test_name, test_data)
+    subject.all.count.should == 3
+  end
+end

data/spec/lib/log_spec.rb

@@ -0,0 +1,155 @@
+require 'spec_helper'
+
+describe Log do
+  subject { Log }
+
+  let(:severity) { :error }
+  let(:test_message) { "Test message" }
+  let(:test_context) { { :foo => 2, :bar => "hello" } }
+
+  let(:event_name) { "Event name" }
+  let(:event_data) { { :ev_data => 5 } }
+
+  let(:error_context) { { :error => 10 } }
+  let(:error_message) { Log::LoggableError.new("Loggable Error Message", error_context) }
+
+  before(:each) do
+    subject.clear_events
+  end
+
+  describe "log.writes" do
+    shared_examples_for "log severity" do |severity|
+      context "when message is a LoggableError" do
+        it "adds the log data to the context" do
+          new_context = subject.send(:handle_loggable_error, error_message, test_context)
+          new_context.should == test_context.merge(:error_data => error_context)
+        end
+
+        it "adds the error's data to the context" do
+          Log::Dispatcher.should_receive(:dispatch).with(severity, error_message, test_context.merge(:error_data => error_context), Log::Events.all)
+          subject.send(severity, error_message, test_context)
+        end
+      end
+
+      it "dispatches the log data to the loggers" do
+        Log::Dispatcher.should_receive(:dispatch).with(severity, test_message, test_context, Log::Events.all)
+        subject.send(severity, test_message, test_context)
+      end
+    end
+
+    Log::SEVERITIES.each_key do |severity|
+      describe severity do
+        it_behaves_like "log severity", severity
+      end
+    end
+  end
+
+  describe "log.asserts" do
+
+    describe "assert" do
+
+      context "when condition is true" do
+        it "returns true" do
+          subject.assert(true, test_message, test_context).should == true
+        end
+
+        it "doesn't fail" do
+          subject.should_not_receive(:assert_failed)
+          subject.assert(true, test_message, test_context)
+        end
+      end
+
+      context "when condition is false" do
+        it "fails" do
+          subject.should_receive(:assert_failed)
+          subject.assert(false, test_message, test_context)
+        end
+
+        it "returns false" do
+          subject.stub(:assert_failed)
+          subject.assert(false, test_message, test_context).should == false
+        end
+      end
+    end
+
+    describe "assert_failed" do
+
+      before do
+        Log.config.raise_on_log_failure = false
+      end
+
+      it "writes to log" do
+        subject.should_receive(:write).with(severity, test_message, test_context)
+        subject.send(:assert_failed, severity, test_message, test_context, false)
+      end
+
+      def should_raise_an_error(raise_error_flag)
+        expect {
+            subject.send(:assert_failed, severity, test_message, test_context, raise_error_flag)
+          }.to raise_error(Log::LoggableError)
+      end
+
+      def should_not_raise_an_error(raise_error_flag)
+          expect {
+              subject.send(:assert_failed, severity, test_message, test_context, raise_error_flag)
+            }.not_to raise_error
+      end
+
+      context "config is false" do
+
+        before do
+          subject.config.raise_on_failed_asserts = false
+        end
+
+        it "should raise error when flag is true" do
+            should_raise_an_error(true)
+        end
+
+        it "should not raise error when flag is nil" do
+            should_not_raise_an_error(nil)
+        end
+
+        it "should not raise error when flag is false" do
+            should_not_raise_an_error(false)
+        end
+      end
+
+      context "config is true" do
+
+        before do
+          subject.config.raise_on_failed_asserts = true
+        end
+
+        it "should raise error when flag is true" do
+            should_raise_an_error(true)
+        end
+
+        it "should raise error when flag is nil" do
+            should_raise_an_error(nil)
+        end
+
+        it "should not raise error when flag is false" do
+            should_not_raise_an_error(false)
+        end
+
+      end
+    end
+  end
+
+  describe "write events" do
+    describe "event" do
+      it "adds an event to the events array" do
+        Log::Events.should_receive(:add).with(event_name, event_data)
+        subject.event(event_name, event_data)
+      end
+    end
+
+    describe "clear_events" do
+      it "resets the events array" do
+        Log::Events.should_receive(:reset)
+        subject.clear_events
+      end
+    end
+  end
+
+end

data/spec/lib/loggable_error_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+#require 'lib/log/loggable_error'
+
+describe Log::LoggableError do
+  subject { Log::LoggableError }
+
+  let (:test_message) { "test message" }
+  let (:test_data) { { :a => 2 } }
+
+  it "contains the error data" do
+    error = subject.new(test_message, test_data)
+    error.data.should == test_data
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'batlog'
+
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+end

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification 
+name: batlog
+version: !ruby/object:Gem::Version 
+  hash: 25
+  prerelease: 
+  segments: 
+  - 0
+  - 9
+  version: "0.9"
+platform: ruby
+authors: 
+- Asaf Gartner
+- Yonatan Bergman
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-10-22 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: 
+email: agartner@ebay.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gemspec
+- .gitignore
+- .rspec
+- .rvmrc
+- .travis.yml
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- app/models/log/db_log.rb
+- lib/batlog.rb
+- lib/log/config.rb
+- lib/log/controller_support.rb
+- lib/log/dispatcher.rb
+- lib/log/engine.rb
+- lib/log/events.rb
+- lib/log/log.rb
+- lib/log/loggable_error.rb
+- lib/log/utils.rb
+- lib/log/version.rb
+- lib/loggers/database_logger.rb
+- lib/loggers/exceptional_logger.rb
+- lib/loggers/rails_logger.rb
+- spec/lib/dispatcher_spec.rb
+- spec/lib/events_spec.rb
+- spec/lib/log_spec.rb
+- spec/lib/loggable_error_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/TheGiftsProject/batlog
+licenses: []
+
+post_install_message: Run 'rails generate db_log' and then migrate to start using the log with database backend
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A structured logging system
+test_files: 
+- spec/lib/dispatcher_spec.rb
+- spec/lib/events_spec.rb
+- spec/lib/log_spec.rb
+- spec/lib/loggable_error_spec.rb