semantic_logger 0.0.2

data/lib/semantic_logger/rails.rb

@@ -0,0 +1,48 @@
+#
+# IGNORE THIS FILE
+#
+
+module SemanticLogger
+  module Appender
+    # Logger appender
+    #
+    #   Maps the SemanticLogger API's to the Rails log, or Ruby Logger
+    #
+    #   The following changes are made:
+    #     The klass_name is prefixed on all log entries if available.
+    #
+    # Note: For performance, the original Rails Logger or Ruby Logger is returned,
+    #       with that instance populated with the new API's to support SymanticLogger
+    #
+    # Installation:
+    #    Rails.logger = SemanticLogger::LoggerAppender.new(Rails.logger)
+    # Also works with the Ruby Logger
+    #    logger = Logger.new ....
+    #    Rails.log = LoggerAppender.new()
+    #
+    # ActiveResource::BufferedLogger
+    #    ...
+    #
+    # Append to the default Rails log
+    #
+    # Note: The Rails log must be initialized prior to this Appender being started
+    #       Or, the original Rails log must be passed into the initializer
+    #
+    class Logger
+      @@level_map = {:trace => :debug, :debug=>:debug, :info=>:info, :warn=>:warn, :error=>:error}
+
+      # These are a problem at the appender level, need to move to API
+      # Not consistent with the other appenders levels
+      def level
+        @logger.level
+      end
+
+      def level=(new_level)
+        @logger.level = new_level
+      end
+
+
+
+    end
+  end
+end

data/lib/semantic_logger/railtie.rb

@@ -0,0 +1,43 @@
+module SemanticLogger #:nodoc:
+  class Railtie < Rails::Railtie #:nodoc:
+    # Make the SemanticLogger config available in the Rails application config
+    #
+    # Example: Add the MongoDB logging appender in the Rails environment
+    #          initializer in file config/environments/development.rb
+    #
+    #   Claritybase::Application.configure do
+    #     # Add the MongoDB logger appender only once Rails is initialized
+    #     config.after_initialize do
+    #       config.semantic_logger.appenders << SemanticLogger::Appender::Mongo.new(
+    #         :db => Cache::Work.db
+    #        )
+    #     end
+    #   end
+    config.semantic_logger = ::SemanticLogger::Logger
+
+    # Initialize SemanticLogger. In a Rails environment it will automatically
+    # insert itself above the configured rails logger to add support for its
+    # additional features
+    #
+    # Also, if Mongoid is installed it will automatically start logging to Mongoid
+    #
+    # Loaded after Rails logging is initialized since SemanticLogger will continue
+    # to forward logging to the Rails Logger
+    initializer :initialize_semantic_logger, :after => :initialize_logger do
+      config = Rails.application.config
+
+      # Add the Rails Logger to the list of appenders
+      SemanticLogger::Logger.appenders << SemanticLogger::Appender::Logger.new(Rails.logger)
+
+      # Set the default log level based on the Rails config
+      SemanticLogger::Logger.default_level = Rails.configuration.log_level
+
+      # Replace the default Rails loggers
+      Rails.logger = config.logger = SemanticLogger::Logger.new(Rails)
+      if defined?(ActiveRecord)
+        ActiveRecord::Base.logger = SemanticLogger::Logger.new(ActiveRecord)
+      end
+    end
+
+  end
+end

data/lib/semantic_logger/version.rb

@@ -0,0 +1,3 @@
+module SemanticLogger #:nodoc
+  VERSION = "0.0.2"
+end

data/lib/semantic_logger.rb

@@ -0,0 +1,18 @@
+# Temp until in Gemfile
+require 'sync_attr'
+
+module SemanticLogger
+  autoload :Logger, 'semantic_logger/logger'
+
+  module Appender
+    autoload :Logger, 'semantic_logger/appender/logger'
+    # Only load the MongoDB appender if the Mongo Ruby Driver is loaded
+    if defined?(Mongo)
+      autoload :MongoDB, 'semantic_logger/appender/mongodb'
+    end
+  end
+end
+
+if defined?(Rails)
+  require 'semantic_logger/railtie'
+end

data/test/appender_logger_test.rb

@@ -0,0 +1,78 @@
+# Allow test to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'logger'
+require 'semantic_logger/appender/logger'
+require 'test/mock_logger'
+
+# Unit Test for SemanticLogger::Appender::Logger
+#
+class AppenderLoggerTest < Test::Unit::TestCase
+  context SemanticLogger::Appender::Logger do
+    setup do
+      @time = Time.parse("2012-08-02 09:48:32.482")
+    end
+
+    context "format messages into text form" do
+      setup do
+        @hash = { :session_id=>"HSSKLEU@JDK767", :tracking_number=>12345 }
+      end
+
+      should "handle nil level, application, message and hash" do
+        msg = SemanticLogger::Appender::Logger.format_message(nil, nil, nil, nil)
+        assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+  \[\d+:\w+\]  -- \n/, msg
+      end
+
+      should "handle nil application, message and hash" do
+        msg = SemanticLogger::Appender::Logger.format_message(:debug, nil, nil, nil)
+        assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:\w+\]  -- \n/, msg
+      end
+
+      should "handle nil message and hash" do
+        msg = SemanticLogger::Appender::Logger.format_message(:debug, 'application', nil, nil)
+        assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:\w+\] application -- \n/, msg
+      end
+
+      should "handle nil hash" do
+        msg = SemanticLogger::Appender::Logger.format_message(:debug, 'application', 'hello world', nil)
+        assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:\w+\] application -- hello world\n/, msg
+      end
+
+      should "handle hash" do
+        msg = SemanticLogger::Appender::Logger.format_message(:debug, 'application', 'hello world', @hash)
+        assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:\w+\] application -- hello world -- \{:session_id=>\"HSSKLEU@JDK767\", :tracking_number=>12345\}\n/, msg
+      end
+
+      should "handle block" do
+        msg = SemanticLogger::Appender::Logger.format_message(:debug, 'application', 'hello world', @hash) { "Calculations" }
+        assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:\w+\] application -- hello world -- \{:session_id=>\"HSSKLEU@JDK767\", :tracking_number=>12345\} -- Calculations\n/, msg
+      end
+
+      should "handle block with no other parameters" do
+        msg = SemanticLogger::Appender::Logger.format_message(:debug, nil, nil, nil) { "Calculations" }
+        assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:\w+\]  --  -- Calculations\n/, msg
+      end
+    end
+
+    context "log to Ruby logger" do
+      setup do
+        @mock_logger = MockLogger.new
+        @appender = SemanticLogger::Appender::Logger.new(@mock_logger)
+        @hash = { :tracking_number => 12345, :session_id => 'HSSKLEU@JDK767'}
+      end
+
+      # Ensure that any log level can be logged
+      Logger::Severity.constants.each do |level|
+        should "log #{level.downcase.to_sym} info" do
+          @appender.log(level.downcase.to_sym, 'application', 'hello world', @hash) { "Calculations" }
+          assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:\w+\] application -- hello world -- \{:session_id=>\"HSSKLEU@JDK767\", :tracking_number=>12345\} -- Calculations\n/, @mock_logger.message
+        end
+      end
+
+    end
+
+  end
+end

data/test/appender_mongodb_test.rb

@@ -0,0 +1,117 @@
+# Allow test to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'logger'
+require 'mongo'
+require 'sync_attr'
+require 'semantic_logger/logger'
+require 'semantic_logger/appender/mongodb'
+
+# Unit Test for SemanticLogger::Appender::MongoDB
+#
+class AppenderMongoDBTest < Test::Unit::TestCase
+  context SemanticLogger::Appender::MongoDB do
+    setup do
+      @db = Mongo::Connection.new['test']
+    end
+
+    context "configuration" do
+      #TODO verify configuration setting carry through
+    end
+
+    context "formatter" do
+      setup do
+        @appender = SemanticLogger::Appender::MongoDB.new(
+          :db               => @db,
+          :collection_size  => 10*1024**2, # 10MB
+          :host_name        => 'test',
+          :application      => 'test_application'
+        )
+        @time = Time.parse("2012-08-02 09:48:32.482")
+        @hash = { :session_id=>"HSSKLEU@JDK767", :tracking_number=>12345 }
+      end
+
+      context "format messages into text form" do
+        should "handle nil level, application, message and hash" do
+          document = @appender.formatter.call(nil, nil, nil, nil)
+          assert_equal({ :level=>nil, :time=>document[:time], :name=>nil, :pid=>$PID, :host_name=>"test", :thread=>document[:thread], :application=>'test_application'}, document)
+        end
+
+        should "handle nil application, message and hash" do
+          document = @appender.formatter.call(:debug, nil, nil, nil)
+          assert_equal({ :level=>:debug, :time=>document[:time], :name=>nil, :pid=>$PID, :host_name=>"test", :thread=>document[:thread], :application=>'test_application'}, document)
+        end
+
+        should "handle nil message and hash" do
+          document = @appender.formatter.call(:debug, nil, nil, @hash)
+          assert_equal({ :level=>:debug, :time=>document[:time], :name=>nil, :pid=>$PID, :host_name=>"test", :thread=>document[:thread], :application=>'test_application', :metadata=>{:session_id=>"HSSKLEU@JDK767", :tracking_number=>12345}}, document)
+        end
+
+        should "handle nil hash" do
+          document = @appender.formatter.call(:debug, 'myclass', 'hello world', nil)
+          assert_equal({ :level=>:debug, :time=>document[:time], :name=>'myclass', :pid=>$PID, :host_name=>"test", :thread=>document[:thread], :application=>'test_application', :message=>'hello world'}, document)
+        end
+
+        should "handle hash" do
+          document = @appender.formatter.call(:debug, 'myclass', 'hello world', @hash)
+          assert_equal({ :level=>:debug, :time=>document[:time], :name=>'myclass', :pid=>$PID, :host_name=>"test", :thread=>document[:thread], :application=>'test_application', :message=>'hello world', :metadata=>{:session_id=>"HSSKLEU@JDK767", :tracking_number=>12345}}, document)
+        end
+
+        should "handle string block with no message" do
+          document = @appender.formatter.call(:debug, 'myclass', nil, @hash, Proc.new { "Calculations" })
+          assert_equal({ :level=>:debug, :time=>document[:time], :name=>'myclass', :pid=>$PID, :host_name=>"test", :thread=>document[:thread], :application=>'test_application', :message=>'Calculations', :metadata=>{:session_id=>"HSSKLEU@JDK767", :tracking_number=>12345}}, document)
+        end
+
+        should "handle string block" do
+          document = @appender.formatter.call(:debug, 'myclass', 'hello world', @hash, Proc.new { "Calculations" })
+          assert_equal({ :level=>:debug, :time=>document[:time], :name=>'myclass', :pid=>$PID, :host_name=>"test", :thread=>document[:thread], :application=>'test_application', :message=>'hello world Calculations', :metadata=>{:session_id=>"HSSKLEU@JDK767", :tracking_number=>12345}}, document)
+        end
+
+        should "handle hash block" do
+          document = @appender.formatter.call(:debug, 'myclass', 'hello world', nil, Proc.new { @hash })
+          assert_equal({ :level=>:debug, :time=>document[:time], :name=>'myclass', :pid=>$PID, :host_name=>"test", :thread=>document[:thread], :application=>'test_application', :message=>'hello world', :metadata=>{:session_id=>"HSSKLEU@JDK767", :tracking_number=>12345}}, document)
+        end
+
+        should "handle string block with no other parameters" do
+          document = @appender.formatter.call(:debug, 'myclass', 'hello world', @hash, Proc.new { "Calculations" })
+          assert_equal({ :level=>:debug, :time=>document[:time], :name=>'myclass', :pid=>$PID, :host_name=>"test", :thread=>document[:thread], :application=>'test_application', :message=>'hello world Calculations', :metadata=>{:session_id=>"HSSKLEU@JDK767", :tracking_number=>12345}}, document)
+        end
+
+        should "handle hash block with no other parameters" do
+          document = @appender.formatter.call(:debug, nil, nil, nil, Proc.new { @hash.merge(:message => 'hello world') })
+          assert_equal({ :level=>:debug, :time=>document[:time], :name=>nil, :pid=>$PID, :host_name=>"test", :thread=>document[:thread], :application=>'test_application', :message=>'hello world', :metadata=>{:session_id=>"HSSKLEU@JDK767", :tracking_number=>12345}}, document)
+        end
+      end
+    end
+
+    context "log to Mongo logger" do
+      setup do
+        @appender = SemanticLogger::Appender::MongoDB.new(
+          :db               => @db,
+          :collection_size  => 10*1024**2, # 10MB
+          :host_name        => 'test',
+          :application      => 'test_application'
+        )
+        @hash = { :tracking_number => 12345, :session_id => 'HSSKLEU@JDK767'}
+      end
+
+      teardown do
+        @appender.purge_all
+      end
+
+      # Ensure that any log level can be logged
+      SemanticLogger::Logger::LEVELS.each do |level|
+        should "log #{level} information" do
+          @appender.log(level, 'my_class', 'hello world', @hash) { "Calculations" }
+          document = @appender.collection.find_one
+          assert_equal({"_id"=>document['_id'], "level"=>level, "message"=>"hello world", "thread"=>document['thread'], "time"=>document['time'], 'metadata'=>{'session_id'=>"HSSKLEU@JDK767", 'tracking_number'=>12345}, "name"=>"my_class", "pid"=>document['pid'], "host_name"=>"test", "application"=>"test_application"}, document)
+        end
+      end
+
+    end
+
+  end
+end

data/test/logger_test.rb

@@ -0,0 +1,44 @@
+# Allow test to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'logger'
+require 'semantic_logger'
+require 'test/mock_logger'
+
+# Unit Test for SemanticLogger::Logger
+#
+class LoggerTest < Test::Unit::TestCase
+  context SemanticLogger::Logger do
+
+    context "log to Ruby and Rails logger" do
+      setup do
+        # Use a mock logger that just keeps the last logged entry in an instance variable
+        @mock_logger = MockLogger.new
+        @appender = SemanticLogger::Appender::Logger.new(@mock_logger)
+        SemanticLogger::Logger.appenders << @appender
+
+        # Use this test's class name as the application name in the log output
+        @logger = SemanticLogger::Logger.new('LoggerTest', :level => :trace)
+
+        @hash = { :tracking_number => 12345, :session_id => 'HSSKLEU@JDK767'}
+      end
+
+      teardown do
+        SemanticLogger::Logger.appenders.delete(@appender)
+      end
+
+      # Ensure that any log level can be logged
+      SemanticLogger::Logger::LEVELS.each do |level|
+        should "log #{level} info" do
+          @logger.send(level, 'hello world', @hash) { "Calculations" }
+          assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:\w+\] LoggerTest -- hello world -- \{:session_id=>\"HSSKLEU@JDK767\", :tracking_number=>12345\} -- Calculations\n/, @mock_logger.message
+        end
+      end
+
+    end
+
+  end
+end

data/test/mock_logger.rb

@@ -0,0 +1,25 @@
+# Looks like a standard Ruby Logger or Rails Logger
+# Except that it stores the last logged entry in the instance variable: message
+class MockLogger
+  attr_accessor :message
+
+  Logger::Severity.constants.each do |level|
+    class_eval <<-EOT, __FILE__, __LINE__
+        def #{level.downcase}(message = nil, progname = nil, &block)
+          if message
+            self.message = message
+          elsif block
+            self.message = block.call
+          else
+            self.message = progname
+          end
+          self.message
+        end
+
+        def #{level}?
+          @true
+        end
+    EOT
+  end
+end
+

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: semantic_logger
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Reid Morrison
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-08-08 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: Logging with additional machine readable and parseable log data
+email: 
+- reidmo@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- FUTURE.rb
+- init.txt
+- lib/semantic_logger/appender/logger.rb
+- lib/semantic_logger/appender/mongodb.rb
+- lib/semantic_logger/logger.rb
+- lib/semantic_logger/rails.rb
+- lib/semantic_logger/railtie.rb
+- lib/semantic_logger/version.rb
+- lib/semantic_logger.rb
+- LICENSE.txt
+- Rakefile
+- README.md
+- test/appender_logger_test.rb
+- test/appender_mongodb_test.rb
+- test/logger_test.rb
+- test/mock_logger.rb
+has_rdoc: true
+homepage: https://github.com/ClarityServices/semantic_logger
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Semantic Logger for Ruby, and Ruby on Rails
+test_files: []
+