rails_semantic_logger 1.0.0

data/Gemfile

@@ -0,0 +1,8 @@
+source :rubygems
+
+group :test do
+  gem "shoulda"
+end
+
+gem 'semantic_logger', '>= 2.0.0'
+gem 'rails', '>= 3.0.10'

data/LICENSE.txt

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2012 Clarity Services, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README.md

@@ -0,0 +1,476 @@
+rails_semantic_logger
+=====================
+
+Improved logging for Ruby on Rails
+
+* http://github.com/ClarityServices/rails_semantic_logger
+
+### Overview
+
+Rails Semantic Logger replaces the Rails default logger with [Semantic Logger](http://github.com/ClarityServices/semantic_logger)
+
+[Semantic Logger](http://github.com/ClarityServices/semantic_logger) takes
+logging in Ruby to a new level by adding several new capabilities to the
+commonly used Logging API:
+
+Dynamic
+
+* Increase the log level at runtime for just one class
+* For example enable debug level logging for a single class (logging instance)
+  while the program is running to get more detailed logging in production for just that class
+
+Tagged Logging
+
+* Supply custom data to be added to every log entry within a block of code,
+  including libraries and existing gems
+* Tagged logging is critical for any high traffic site so that one can narrow
+  down log entries for a single call that is mixed in with log entries
+  from hundreds of other log entries
+
+High Performance
+
+* Logging is performed in a separate thread so as not to impact performance of
+  running code
+
+Customizable
+
+* Custom formatting by destination
+* Easy to "roll your own" destination (Appender).
+  For example to log to Hadoop, Redis, etc..
+
+Payload support
+
+* Aside from the regular log message, a hash payload can also be supplied with
+  every log entry
+* Very powerful when logging to NOSQL destinations that allow queries against
+  any data in the payload
+
+Exceptions
+
+* Directly log exceptions
+* Semantic Logger standardizes the logging of exceptions with their backtraces
+  to text destinations and writes the exception elements as a hash to NOSQL
+  destinations
+
+Drop-in Replacement
+
+* Simple drop-in replacement for the Ruby, or the Rails loggers
+* Supports current common logging interface
+* No changes to existing to code to use new logger ( other than replacing the logger )
+
+Rails 2 & 3 Support
+
+* Just include the semantic_logger gem into Rails and it will immediately
+  replace the existing loggers to improve performance and information
+  in the log files
+* The Rails 3 Tagged logging feature is already available for Rails 2 by using Semantic Logger
+
+Thread Aware
+
+* Includes the process and thread id information in every log entry
+* If running JRuby it will also include the name of the thread for every log entry
+
+Trace Level
+
+* :trace is a new level common in other languages and is commonly used for
+  logging trace level detail. It is intended for logging data at level below
+  :debug.
+* :trace can be used for logging the actual data sent or received over the network
+  that is rarely needed but is critical when things are not working as expected.
+* Since :trace can be enabled on a per class basis it can even be turned on
+  in production to resolve what was actually sent to an external vendor
+
+Multiple Destinations
+
+* Log to multiple destinations at the same time ( File and MongoDB, etc.. )
+* Each destination can also have its own log level.
+  For example, only log :info and above to MongoDB, or :warn and above to a
+  second log file
+
+Benchmarking
+
+* The performance of any block of code can be measured and logged at the same time
+  depending on the active log level
+
+Semantic Capabilities
+
+* With Semantic Logger it is simple to mix-in additional semantic information with
+every log entry
+* The application or class name is automatically included for every log entry under
+  a specific logging instance
+* Includes the duration of blocks of code
+* Any hash containing context specific information such as user_id or location information
+
+Beyond Tagged Logging
+
+* Supply entire hash of custom data to be added to the payload of every log entry
+  within a block of code, including libraries and existing gems
+
+NOSQL Destinations
+
+* Every log entry is broken down into elements that NOSQL data stores can understand:
+
+```json
+{
+    "_id" : ObjectId("5034fa48e3f3fea945e83ef2"),
+    "time" : ISODate("2012-08-22T15:27:04.409Z"),
+    "host_name" : "release",
+    "pid" : 16112,
+    "thread_name" : "main",
+    "name" : "UserLocator",
+    "level" : "debug",
+    "message" : "Fetch user information",
+    "duration" : 12,
+    "payload" : {
+        "user" : "Jack",
+        "zip_code" : 12345,
+        "location" : "US"
+    }
+}
+```
+
+Thread Safe
+
+* Semantic Logger is completely thread safe and all methods can be called
+  concurrently from any thread
+* Tagged logging keeps any tagging data on a per-thread basis to ensure that
+  tags from different threads are not inter-mingled
+
+### Introduction
+
+Just by including the rails_semantic_logger gem, Rails Semantic Logger will
+replace the default Rails logger with Semantic Logger. Without further
+configuration it will log to the existing Rails log file in a more efficient
+multi-threaded way.
+
+Extract from a Rails log file after adding the semantic_logger gem:
+
+```
+2012-10-19 12:05:46.736 I [35940:JRubyWorker-10] Rails --
+
+Started GET "/" for 127.0.0.1 at 2012-10-19 12:05:46 +0000
+2012-10-19 12:05:47.318 I [35940:JRubyWorker-10] ActionController --   Processing by AdminController#index as HTML
+2012-10-19 12:05:47.633 D [35940:JRubyWorker-10] ActiveRecord --   User Load (2.0ms)  SELECT `users`.* FROM `users` WHERE `users`.`id` = 1 LIMIT 1
+2012-10-19 12:05:49.833 D [35940:JRubyWorker-10] ActiveRecord --   Role Load (2.0ms)  SELECT `roles`.* FROM `roles`
+2012-10-19 12:05:49.868 D [35940:JRubyWorker-10] ActiveRecord --   Role Load (1.0ms)  SELECT * FROM `roles` INNER JOIN `roles_users` ON `roles`.id = `roles_users`.role_id WHERE (`roles_users`.user_id = 1 )
+2012-10-19 12:05:49.885 I [35940:JRubyWorker-10] ActionController -- Rendered menus/_control_system.html.erb (98.0ms)
+2012-10-19 12:05:51.014 I [35940:JRubyWorker-10] ActionController -- Rendered layouts/_top_bar.html.erb (386.0ms)
+2012-10-19 12:05:51.071 D [35940:JRubyWorker-10] ActiveRecord --   Announcement Load (20.0ms)  SELECT `announcements`.* FROM `announcements` WHERE `announcements`.`active` = 1 ORDER BY created_at desc
+2012-10-19 12:05:51.072 I [35940:JRubyWorker-10] ActionController -- Rendered layouts/_announcement.html.erb (26.0ms)
+2012-10-19 12:05:51.083 I [35940:JRubyWorker-10] ActionController -- Rendered layouts/_flash.html.erb (4.0ms)
+2012-10-19 12:05:51.109 I [35940:JRubyWorker-10] ActionController -- Rendered layouts/_footer.html.erb (16.0ms)
+2012-10-19 12:05:51.109 I [35940:JRubyWorker-10] ActionController -- Rendered admin/index.html.erb within layouts/base (1329.0ms)
+2012-10-19 12:05:51.113 I [35940:JRubyWorker-10] ActionController -- Completed 200 OK in 3795ms (Views: 1349.0ms | ActiveRecord: 88.0ms | Mongo: 0.0ms)
+```
+
+### Logging API
+
+#### Standard Logging methods
+
+The Semantic Logger logging API supports the existing logging interface for
+the Rails and Ruby Loggers. For example:
+
+```ruby
+logger.info("Hello World")
+```
+
+Or to query whether a specific log level is set
+
+```ruby
+logger.info?
+```
+
+The following logging methods are available
+
+```ruby
+trace(message, payload=nil, exception=nil, &block)
+debug(message, payload=nil, exception=nil, &block)
+info(message, payload=nil, exception=nil, &block)
+warn(message, payload=nil, exception=nil, &block)
+error(message, payload=nil, exception=nil, &block)
+fatal(message, payload=nil, exception=nil, &block)
+```
+
+Parameters
+
+- message: The text message to log.
+  Mandatory only if no block is supplied
+- payload: Optional, either a Ruby Exception object or a Hash
+- exception: Optional, Ruby Exception object. Allows both an exception and a payload to be logged
+- block:   The optional block is executed only if the corresponding log level
+  is active. Can be used to prevent unnecessary calculations of debug data in
+  production.
+
+Examples:
+
+```ruby
+logger.debug("Calling Supplier")
+
+logger.debug("Calling Supplier", :request => 'update', :user => 'Jack')
+
+logger.debug { "A total of #{result.inject(0) {|sum, i| i+sum }} were processed" }
+```
+
+### Exceptions
+
+The Semantic Logger adds an optional parameter to the existing log methods so that
+a corresponding Exception can be logged in a standard way
+
+```ruby
+begin
+  # ... Code that can raise an exception
+rescue Exception => exception
+  logger.error("Oops external call failed", exception)
+  # Re-raise or handle the exception
+  raise exception
+end
+```
+
+#### Payload
+
+The Semantic Logger adds an extra parameter to the existing log methods so that
+additional payload can be logged, such as a Hash or a Ruby Exception object.
+
+```ruby
+logger.info("Oops external call failed", :result => :failed, :reason_code => -10)
+```
+
+The additional payload is machine readable so that we don't have to write complex
+regular expressions so that a program can analyze log output. With the MongoDB
+appender the payload is written directly to MongoDB as part of the document and
+is therefore fully searchable
+
+#### Benchmarking
+
+Another common logging requirement is to measure the time it takes to execute a block
+of code based on the log level. For example:
+
+```ruby
+Rails.logger.benchmark_info "Calling external interface" do
+  # Code to call external service ...
+end
+```
+
+The following output will be written to file:
+
+    2012-08-30 15:37:29.474 I [48308:ScriptThreadProcess: script/rails] (5.2ms) Rails -- Calling external interface
+
+If an exception is raised during the block the exception is logged
+at the same log level as the benchmark along with the duration and message.
+The exception will flow through to the caller unchanged
+
+The following benchmarking methods are available
+
+```ruby
+benchmark_trace(message, params=nil, &block)
+benchmark_debug(message, params=nil, &block)
+benchmark_info(message, params=nil, &block)
+benchmark_warn(message, params=nil, &block)
+benchmark_error(message, params=nil, &block)
+benchmark_fatal(message, params=nil, &block)
+```
+
+Parameters
+
+- message: The mandatory text message to log.
+- params:
+```
+  :log_exception
+    Control whether or how an exception thrown in the block is
+    reported by Semantic Logger. Values:
+    :full
+      Log the exception class, message, and backtrace
+    :partial
+      Log the exception class and messag
+      The backtrace will not be logged
+    :off
+      Any unhandled exception from the block will not be logged
+
+  :min_duration
+    Only log if the block takes longer than this duration in ms
+    Default: 0.0
+
+  :payload
+    Optional, Hash payload
+
+  :exception
+    Optional, Ruby Exception object to log along with the duration of the supplied block
+```
+
+#### Logging levels
+
+The following logging levels are available through Semantic Logger
+
+    :trace, :debug, :info, :warn, :error, :fatal
+
+The log levels are listed above in the order of precedence with the most detail to the least.
+For example :debug would include :info, :warn, :error, :fatal levels but not :trace
+And :fatal would only log :fatal error messages and nothing else
+
+:unknown has been mapped to :fatal for Rails and Ruby Logger
+
+:trace is a new level that is often used for tracing low level calls such
+as the data sent or received to external web services. It is also commonly used
+in the development environment for low level trace logging of methods calls etc.
+
+If only the rails logger is being used, then :trace level calls will be logged
+as debug calls only if the log level is set to trace
+
+#### Changing the Class name for Log Entries
+
+When Semantic Logger is included in a Rails project it automatically replaces the
+loggers for Rails, ActiveRecord::Base, ActionController::Base, and ActiveResource::Base
+with wrappers that set their Class name. For example:
+
+```ruby
+ActiveRecord::Base.logger = SemanticLogger::Logger.new(ActiveRecord)
+```
+
+By replacing their loggers we now get the class name in the text logging output:
+
+    2012-08-30 15:24:13.439 D [47900:main] ActiveRecord --   SQL (12.0ms)  SELECT `schema_migrations`.`version` FROM `schema_migrations`
+
+It is recommended to include a class specific logger for all major classes that will
+be logging using the SemanticLogger::Loggable mix-in. For Example:
+
+```ruby
+require 'semantic_logger'
+
+class ExternalSupplier
+  # Lazy load logger class variable on first use
+  include SemanticLogger::Loggable
+
+  def call_supplier(amount, name)
+    logger.debug "Calculating with amount", { :amount => amount, :name => name }
+
+    # Measure and log on completion how long the call took to the external supplier
+    logger.benchmark_info "Calling external interface" do
+      # Code to call the external supplier ...
+    end
+  end
+end
+```
+
+This will result in the log output identifying the log entry as from the ExternalSupplier class
+
+    2012-08-30 15:37:29.474 I [48308:ScriptThreadProcess: script/rails] (5.2ms) ExternalSupplier -- Calling external interface
+
+#### Tagged Logging
+
+Semantic Logger allows any Ruby or Rails program to also include tagged logging.
+
+This means that any logging performed within a block, including any called
+libraries or gems to include the specified tag with every log entry.
+
+Using Tagged logging is critical in any highly concurrent environment so that
+one can quickly find all related log entries across all levels of code, and even
+across threads
+
+```ruby
+logger.tagged(tracking_number) do
+  logger.debug("Hello World")
+  # ...
+end
+```
+
+#### Beyond Tagged Logging
+
+Blocks of code can be tagged with not only values, but can be tagged with
+entire hashes of data. The additional hash of data will be merged into
+the payload of every log entry
+
+For example every corresponding log entry could include a hash containing
+a user_id, name, region, zip_code, tracking_number, etc...
+
+```ruby
+logger.with_payload(:user => 'Jack', :zip_code => 12345) do
+  logger.debug("Hello World")
+  # ...
+end
+```
+
+#### Installation
+
+Add the following line to Gemfile
+
+```ruby
+gem 'rails_semantic_logger'
+```
+
+Install required gems with bundler
+
+    bundle install
+
+This will automatically replace the standard Rails logger with Semantic Logger
+which will write all log data to the configured Rails logger.
+
+#### Configuration
+
+By default Semantic Logger will detect the log level from Rails. To set the
+log level explicitly, add the following line to
+config/environments/production.rb inside the Application.configure block
+
+```ruby
+config.log_level = :trace
+```
+
+To log to both the Rails log file and MongoDB add the following lines to
+config/environments/production.rb inside the Application.configure block
+
+```ruby
+config.after_initialize do
+  # Re-use the existing MongoDB connection, or create a new one here
+  db = Mongo::Connection.new['production_logging']
+
+  # Besides logging to the standard Rails logger, also log to MongoDB
+  config.semantic_logger.appenders << SemanticLogger::Appender::MongoDB.new(
+    :db              => db,
+    :collection_size => 25.gigabytes
+  )
+end
+```
+### Custom Appenders and Formatters
+
+To write your own appenders or formatting, see [SemanticLogger](http://github.com/ClarityServices/semantic_logger)
+
+### Log Rotation
+
+Since the log file is not re-opened with every call, when the log file needs
+to be rotated, use a copy-truncate operation rather than deleting the file.
+
+### Dependencies
+
+- Ruby MRI 1.8.7, 1.9.3 (or above) Or, JRuby 1.6.3 (or above)
+- Rails 2 or above
+
+Meta
+----
+
+* Code: `git clone git://github.com/ClarityServices/rails_semantic_logger.git`
+* Home: <https://github.com/ClarityServices/rails_semantic_logger>
+* Bugs: <http://github.com/ClarityServices/rails_semantic_logger/issues>
+* Gems: <http://rubygems.org/gems/rails_semantic_logger>
+
+This project uses [Semantic Versioning](http://semver.org/).
+
+Authors
+-------
+
+Reid Morrison :: reidmo@gmail.com :: @reidmorrison
+
+License
+-------
+
+Copyright 2012 Clarity Services, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/Rakefile

@@ -0,0 +1,29 @@
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'rubygems'
+require 'rake/clean'
+require 'rake/testtask'
+require 'date'
+require 'rails_semantic_logger/version'
+
+desc "Build gem"
+task :gem  do |t|
+  gemspec = Gem::Specification.new do |spec|
+    spec.name        = 'rails_semantic_logger'
+    spec.version     = RailsSemanticLogger::VERSION
+    spec.platform    = Gem::Platform::RUBY
+    spec.authors     = ['Reid Morrison']
+    spec.email       = ['reidmo@gmail.com']
+    spec.homepage    = 'https://github.com/ClarityServices/rails_semantic_logger'
+    spec.date        = Date.today.to_s
+    spec.summary     = "Improved logging for Ruby on Rails"
+    spec.description = "Replaces the default Rails logger with SemanticLogger"
+    spec.files       = FileList["./**/*"].exclude(/.gem$/, /.log$/,/^nbproject/).map{|f| f.sub(/^\.\//, '')}
+    spec.has_rdoc    = true
+    spec.add_dependency 'semantic_logger', '>= 2'
+    spec.add_dependency 'rails', '>= 2'
+  end
+  Gem::Builder.new(gemspec).build
+end
+

data/lib/rails_semantic_logger.rb

@@ -0,0 +1,2 @@
+require 'semantic_logger'
+require 'rails_semantic_logger/railtie'

data/lib/rails_semantic_logger/railtie.rb

@@ -0,0 +1,73 @@
+require 'logger'
+module RailsSemanticLogger #: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 => Mongo::Connection.new['development_development']
+    #        )
+    #     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, :before => :initialize_logger do
+      config = Rails.application.config
+
+      # Set the default log level based on the Rails config
+      SemanticLogger::Logger.default_level = config.log_level
+
+      # Existing loggers are ignored because servers like trinidad supply their
+      # own file loggers which would result in duplicate logging to the same log file
+      Rails.logger = config.logger = begin
+        # First check for Rails 3.2 path, then fallback to pre-3.2
+        path = ((config.paths.log.to_a rescue nil) || config.paths['log']).first
+        unless File.exist? File.dirname path
+          FileUtils.mkdir_p File.dirname path
+        end
+
+        # Set internal logger to log to file only, in case another appender
+        # experiences errors during writes
+        appender = SemanticLogger::Appender::File.new(path, config.log_level)
+        appender.name = "SemanticLogger::Logger"
+        SemanticLogger::Logger.logger = appender
+
+        # Add the log file to the list of appenders
+        SemanticLogger::Logger.appenders << SemanticLogger::Appender::File.new(path)
+        SemanticLogger::Logger.new(Rails)
+      rescue StandardError
+        # If not able to log to file, log to standard error with warning level only
+        SemanticLogger::Logger.default_level = :warn
+
+        SemanticLogger::Logger.logger = SemanticLogger::Appender::File.new(STDERR)
+        SemanticLogger::Logger.appenders << SemanticLogger::Appender::File.new(STDERR)
+
+        logger = SemanticLogger::Logger.new(Rails)
+        logger.warn(
+          "Rails Error: Unable to access log file. Please ensure that #{path} exists and is chmod 0666. " +
+            "The log level has been raised to WARN and the output directed to STDERR until the problem is fixed."
+        )
+        logger
+      end
+
+      # Replace the default Rails loggers
+      ActiveSupport.on_load(:active_record)     { self.logger = SemanticLogger::Logger.new('ActiveRecord') }
+      ActiveSupport.on_load(:action_controller) { self.logger = SemanticLogger::Logger.new('ActionController') }
+      ActiveSupport.on_load(:action_mailer)     { self.logger = SemanticLogger::Logger.new('ActionMailer') }
+    end
+
+  end
+end

data/lib/rails_semantic_logger/version.rb

@@ -0,0 +1,3 @@
+module RailsSemanticLogger #:nodoc
+  VERSION = "1.0.0"
+end

data/nbproject/private/private.properties

@@ -0,0 +1 @@
+file.reference.rails_semantic_logger-lib=/Users/rmorrison/Sandbox/rails_semantic_logger/lib

data/nbproject/project.properties

@@ -0,0 +1,5 @@
+file.reference.rails_semantic_logger-lib=lib
+main.file=
+platform.active=Ruby_0
+source.encoding=UTF-8
+src.dir=${file.reference.rails_semantic_logger-lib}

data/nbproject/project.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://www.netbeans.org/ns/project/1">
+    <type>org.netbeans.modules.ruby.rubyproject</type>
+    <configuration>
+        <data xmlns="http://www.netbeans.org/ns/ruby-project/1">
+            <name>rails_semantic_logger</name>
+            <source-roots>
+                <root id="src.dir"/>
+            </source-roots>
+            <test-roots/>
+        </data>
+    </configuration>
+</project>

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification 
+name: rails_semantic_logger
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Reid Morrison
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-12-20 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: semantic_logger
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        version: "2"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        version: "2"
+  type: :runtime
+  version_requirements: *id002
+description: Replaces the default Rails logger with SemanticLogger
+email: 
+- reidmo@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Gemfile
+- lib/rails_semantic_logger/railtie.rb
+- lib/rails_semantic_logger/version.rb
+- lib/rails_semantic_logger.rb
+- LICENSE.txt
+- nbproject/private/private.properties
+- nbproject/project.properties
+- nbproject/project.xml
+- Rakefile
+- README.md
+has_rdoc: true
+homepage: https://github.com/ClarityServices/rails_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: Improved logging for Ruby on Rails
+test_files: []
+