mongodb_logger 0.1.0

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.project
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+test/log
+tmp
+.DS_Store

data/.rvmrc

@@ -0,0 +1 @@
+rvm ruby-1.9.3-p0@mongodb_logger_gems --create

data/.travis.yml

@@ -0,0 +1,17 @@
+#before_script:
+#  - "rake vendor_test_gems"
+script: "sh -c 'test/test.sh'"
+rvm:
+  - 1.8.7
+  - ree
+  - 1.9.2
+  - 1.9.3
+  - ruby-head
+notifications:
+  email: false
+branches:
+  only:
+    - master
+    - development
+    - gem
+#bundler_args: --path vendor/bundle

data/Gemfile

@@ -0,0 +1,4 @@
+source 'http://rubygems.org'
+
+# Specify your gem's dependencies in mongodb_logger.gemspec
+gemspec

data/README.md

@@ -0,0 +1,177 @@
+# MongodbLogger [![Build Status](https://secure.travis-ci.org/le0pard/mongodb_logger.png)](http://travis-ci.org/le0pard/mongodb_logger)
+
+MongodbLogger is a alternative logger for Rails 3, which log all requests off you application into MongoDB database. 
+It:
+
+* simple to integrate into existing Rails 3 application;
+* allow to store all logs from web cluster into one scalable storage - MongoDB;
+* flexible schema of MongoDB allow to store and search any information from logs;
+* web panel allow filter logs, build graphs using MapReduce by information from logs;
+
+## Installation
+
+1. Add the following to your Gemfile then refresh your dependencies by executing "bundle install" (or just simple "bundle"):
+
+        gem "mongodb_logger"
+
+1. Add the following line to your ApplicationController:
+
+        include MongodbLogger::Base
+
+1. Add MongodbLogger settings to database.yml for each environment in which you want to use the MongodbLogger. The MongodbLogger will also
+   look for a separate mongodb\_logger.yml or mongoid.yml (if you are using mongoid) before looking in database.yml.
+   In the mongodb\_logger.yml and mongoid.yml case, the settings should be defined without the 'mongodb\_logger' subkey.
+
+   File: database.yml:
+
+     development:
+       adapter: postgresql
+       database: my_app_development
+       username: postgres
+       mongodb_logger:
+         database: my_app               # required (the only required setting)
+         capsize: <%= 10.megabytes %>   # default: 250MB
+         host: localhost                # default: localhost
+         port: 27017                    # default: 27017
+         replica_set: true              # default: false - Adds retries for ConnectionFailure during voting for replica set master
+         safe_insert: false             # default: false - Enable/Disable safe inserts (wait for insert to propagate to all nodes)
+         application_name: my_app       # default: Rails.application
+         disable_file_logging: false    # default: false - disable logging into filesystem (only in MongoDB)
+         collection: some_name          # default: Rails.env + "_log" - name of MongoDB collection
+
+   File: mongodb\_logger.yml:
+
+     development:
+       database: my_app
+       capsize: <%= 10.megabytes %>
+       host: localhost
+       port: 27017
+       replica_set: true
+  
+  
+## Usage
+
+  After success instalation of gem, a new MongoDB document (record) will be created for each request on your application,
+  by default will record the following information: Runtime, IP Address, Request Time, Controller, Method, 
+  Action, Params, Application Name and All messages sent to the logger. The structure of the MongoDB document looks like this:
+
+      {
+        'action'           : action_name,
+        'application_name' : application_name (rails root),
+        'controller'       : controller_name,
+        'ip'               : ip_address,
+        'messages'         : {
+                               'info'  : [ ],
+                               'debug' : [ ],
+                               'error' : [ ],
+                               'warn'  : [ ],
+                               'fatal' : [ ]
+                             },
+        'params'           : { },
+        'path'             : path,
+        'request_time'     : date_of_request,
+        'runtime'          : elapsed_execution_time_in_milliseconds,
+        'url'              : full_url,
+        'method'           : request method (GET, POST, PUT, DELETE, OPTIONS)
+      }
+
+  Beyond that, if you want to add extra information to the base of the document (let's say something like user\_id on every request that it's available),
+  you can just call the Rails.logger.add\_metadata method on your logger like so (for example from a before\_filter):
+
+      # make sure we're using the MongodbLogger in this environment
+      if Rails.logger.respond_to?(:add_metadata)
+       Rails.logger.add_metadata(:user_id => @current_user.id)
+      end
+
+
+## The Front End
+  To setup web interface in you Rails application, first of all create autoload file in you Rails application 
+   
+   File: you\_rails\_app/config/initializers/mongodb\_logger.rb (example)
+        
+        require 'mongodb_logger/server' # required
+        # this secure you web interface by basic auth, but you can skip this, if you no need this
+        MongodbLogger::Server.use Rack::Auth::Basic do |username, password|
+            [username, password] == ['admin', 'password']
+        end
+   
+   and just mount MongodbLogger::Server in rails routes:
+    
+   File: you\_rails\_app/config/routes.rb
+        
+        mount MongodbLogger::Server.new, :at => "/mongodb"
+        
+  Now you can see web interface by url "http://localhost:3000/mongodb"
+  
+  If you've installed Resque as a gem and want running the front end without Rails application, you can do it by this command:
+  
+      mongodb_logger_web config.yml
+      
+  where config.yml is config, similar to config of Rails apps, but without Rails.env. Example:
+      
+      database: app_logs_dev
+      host: localhost
+      port: 27017
+      collection: development_log # set for see development logs
+      
+  parameter "collection" should be set, if your set custom for your Rails application or start this front end not for production
+  enviroment (by default taken "production\_log" collection, in Rails application gem generate "#{Rails.env}\_log" collection, 
+  if it is not defined in config).
+  
+  It's a thin layer around rackup so it's configurable as well:
+  
+      mongodb_logger_web config.yml -p 8282
+      
+###  Passenger
+
+  Using Passenger? MongodbLogger ships with a `config.ru` you can use. See Phusion's guide:
+
+  * Apache: <http://www.modrails.com/documentation/Users%20guide%20Apache.html#_deploying_a_rack_based_ruby_application>
+  * Nginx: <http://www.modrails.com/documentation/Users%20guide%20Nginx.html#deploying_a_rack_app>
+  
+  Don't forget setup MONGODBLOGGERCONFIG env variable, which provide information about MongodbLogger config. Example starting with unicorn:
+  
+      MONGODBLOGGERCONFIG=examples/server_config.yml unicorn
+
+## Querying via the Rails console
+
+  And now, for a couple quick examples on getting ahold of this log data...
+  First, here's how to get a handle on the MongoDB from within a Rails console:
+
+      >> db = Rails.logger.mongo_connection
+      => #<Mongo::DB:0x007fdc7c65adc8 @name="monkey_logs_dev" ... >
+
+      >> collection = db[Rails.logger.mongo_collection_name]
+      => #<Mongo::Collection:0x007fdc7a4d12b0 @name="development_log" .. >
+
+  Once you've got the collection, you can find all requests for a specific user (with id):
+
+      >> cursor = collection.find(:user_id => '12355')
+      => #<Mongo::Cursor:0x1031a3e30 ... >
+      >> cursor.count
+      => 5
+
+  Find all requests that took more that one second to complete:
+
+      >> collection.find({:runtime => {'$gt' => 1000}}).count
+      => 3
+
+  Find all order#show requests with a particular order id (id=order\_id):
+
+      >> collection.find({"controller" => "order", "action"=> "show", "params.id" => order_id})
+
+  Find all requests with an exception that contains "RoutingError" in the message or stack trace:
+
+      >> collection.find({"messages.error" => /RoutingError/})
+      
+  Find all requests with errors:
+
+      >> collection.find({"is_exception" => true})
+
+  Find all requests with a request\_date greater than '11/18/2010 22:59:52 GMT'
+
+      >> collection.find({:request_time => {'$gt' => Time.utc(2010, 11, 18, 22, 59, 52)}})
+
+      
+      
+Copyright (c) 2009-2011 Phil Burrows, CustomInk and Leopard released under the MIT license

data/Rakefile

@@ -0,0 +1,110 @@
+#!/usr/bin/env rake
+require 'rake'
+require 'rake/testtask'
+begin
+  require 'cucumber/rake/task'
+rescue LoadError
+  $stderr.puts "Please install cucumber: `gem install cucumber`"
+  exit 1
+end
+
+require "bundler/gem_tasks"
+
+
+desc 'Default: run unit tests.'
+task :default => [:test]
+#task :default => [:test, "cucumber:rails:all"]
+
+desc "Clean out the tmp directory"
+task :clean do
+  exec "rm -rf tmp"
+end
+
+desc 'Test the airbrake gem.'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/unit/mongodb_logger_test.rb'
+  test.verbose = true
+end
+
+namespace :test do
+
+  desc "Run replica set tests (not for CI)"
+  Rake::TestTask.new(:replica_set) do |test|
+    test.libs << 'lib' << 'test'
+    test.pattern = 'test/unit/mongodb_logger_replica_test.rb'
+    test.verbose = true
+  end
+  
+end
+
+
+GEM_ROOT = File.dirname(__FILE__).freeze
+LOCAL_GEM_ROOT = File.join(GEM_ROOT, 'tmp', 'local_gems').freeze
+RAILS_VERSIONS = IO.read('SUPPORTED_RAILS_VERSIONS').strip.split("\n")
+LOCAL_GEMS = [['sqlite3', nil], ['shoulda', nil], ["rspec", nil], ["mocha", nil], ["cucumber", nil], ["bundler", "1.0.21"]] +
+  RAILS_VERSIONS.collect { |version| ['rails', version] }
+
+desc "Vendor test gems: Run this once to prepare your test environment"
+task :vendor_test_gems do
+  old_gem_path = ENV['GEM_PATH']
+  old_gem_home = ENV['GEM_HOME']
+  ENV['GEM_PATH'] = LOCAL_GEM_ROOT
+  ENV['GEM_HOME'] = LOCAL_GEM_ROOT
+  LOCAL_GEMS.each do |gem_name, version|
+    gem_file_pattern = [gem_name, version || '*'].compact.join('-')
+    version_option = version ? "-v #{version}" : ''
+    pattern = File.join(LOCAL_GEM_ROOT, 'gems', "#{gem_file_pattern}")
+    existing = Dir.glob(pattern).first
+    unless existing
+      command = "gem install -i #{LOCAL_GEM_ROOT} --no-ri --no-rdoc --backtrace #{version_option} #{gem_name}"
+      puts "Vendoring #{gem_file_pattern}..."
+      unless system("#{command} 2>&1")
+        puts "Command failed: #{command}"
+        exit(1)
+      end
+    end
+  end
+  ENV['GEM_PATH'] = old_gem_path
+  ENV['GEM_HOME'] = old_gem_home
+end
+
+Cucumber::Rake::Task.new(:cucumber) do |t|
+  t.fork = true
+  t.cucumber_opts = ['--format', (ENV['CUCUMBER_FORMAT'] || 'progress')]
+end
+
+task :cucumber => [:vendor_test_gems]
+
+def run_rails_cucumbr_task(version, additional_cucumber_args)
+  puts "Testing Rails #{version}"
+  if version.empty?
+    raise "No Rails version specified - make sure ENV['RAILS_VERSION'] is set, e.g. with `rake cucumber:rails:all`"
+  end
+  ENV['RAILS_VERSION'] = version
+  system("cucumber --format #{ENV['CUCUMBER_FORMAT'] || 'progress'} #{additional_cucumber_args} features/rails.feature")
+end
+
+def define_rails_cucumber_tasks(additional_cucumber_args = '')
+  namespace :rails do
+    RAILS_VERSIONS.each do |version|
+      desc "Test integration of the gem with Rails #{version}"
+      task version => [:vendor_test_gems] do
+        exit 1 unless run_rails_cucumbr_task(version, additional_cucumber_args)
+      end
+    end
+
+    desc "Test integration of the gem with all Rails versions"
+    task :all do
+      results = RAILS_VERSIONS.map do |version|
+        run_rails_cucumbr_task(version, additional_cucumber_args)
+      end
+
+      exit 1 unless results.all?
+    end
+  end
+end
+
+namespace :cucumber do
+  define_rails_cucumber_tasks
+end

data/SUPPORTED_RAILS_VERSIONS

@@ -0,0 +1,13 @@
+3.0.0
+3.0.1
+3.0.2
+3.0.3
+3.0.4
+3.0.5
+3.0.6
+3.0.7
+3.0.8
+3.0.9
+3.0.10
+3.1.0
+3.1.1

data/TESTING.md

@@ -0,0 +1,24 @@
+Running the suite
+=================
+
+Since the logger must run on many versions of Rails, running its test suite is slightly different than you may be used to.
+
+First execute the following command:
+
+    rake vendor_test_gems
+    # NOT: bundle exec rake vendor_test_gems
+
+This command will download the various versions of Rails that the notifier must be tested against.
+
+Then, to start the suite, run
+
+    rake cucumber:rails:all
+
+Note: do NOT use 'bundle exec rake cucumber:rails:all'.
+
+For help created file test/test.sh, which run all this testing steps + unit tests. Run this file from root of gem:
+
+    ./test/test.sh
+    
+Versions of testing Rails you can see in file "SUPPORTED_RAILS_VERSIONS". If some tests is faild, you can see 
+more information about fallen tests in file "tmp/terminal.log".

data/bin/mongodb_logger_web

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+begin
+  require 'vegas'
+rescue LoadError
+  require 'rubygems'
+  require 'vegas'
+end  
+require 'mongodb_logger/server'
+
+
+Vegas::Runner.new(MongodbLogger::Server, 'mongodb_logger_web', {
+  :before_run => lambda {|v|
+    config_file = (ENV['MONGODBLOGGERCONFIG'] || v.args.first)
+    if config_file
+      MongodbLogger::ServerConfig.set_config(config_file)
+    else
+      raise ArgumentError, "please provide config file"
+    end
+  }
+}) do |runner, opts, app|
+  # 
+end

data/config.ru

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+require 'logger'
+
+$LOAD_PATH.unshift ::File.expand_path(::File.dirname(__FILE__) + '/lib')
+require 'mongodb_logger/server'
+
+# Set the RESQUECONFIG env variable if you've a `resque.rb` or similar
+# config file you want loaded on boot.
+if ENV['MONGODBLOGGERCONFIG'] && ::File.exists?(::File.expand_path(ENV['MONGODBLOGGERCONFIG']))
+  MongodbLogger::ServerConfig.set_config(::File.expand_path(ENV['MONGODBLOGGERCONFIG']))
+else
+  raise "Please provide config file"
+end
+
+use Rack::ShowExceptions
+run MongodbLogger::Server.new

data/examples/server_config.yml

@@ -0,0 +1,4 @@
+database: monkey_logs_dev
+host: localhost
+port: 27017
+collection: development_log

data/features/rails.feature

@@ -0,0 +1,10 @@
+Feature: Install the Gem in a Rails application and test it
+
+  Background:
+    Given I have built and installed the "mongodb_logger" gem
+
+  Scenario: Use the gem without vendoring the gem in a Rails application
+    When I generate a new Rails application
+    And I configure my application to require the "mongodb_logger" gem
+    And I setup mongodb_logger tests
+    Then the tests should have run successfully

data/features/step_definitions/rails_application_steps.rb

@@ -0,0 +1,48 @@
+require 'active_support/core_ext/string/inflections'
+
+Given /^I have built and installed the "([^\"]*)" gem$/ do |gem_name|
+  @terminal.build_and_install_gem(File.join(PROJECT_ROOT, "#{gem_name}.gemspec"))
+end
+
+When /^I generate a new Rails application$/ do
+  @terminal.cd(TEMP_DIR)
+  version_string = ENV['RAILS_VERSION']
+  rails_create_command = 'new'
+
+  load_rails = <<-RUBY
+    gem "rails", "#{version_string}"; \
+    load Gem.bin_path("rails", "rails", "#{version_string}")
+  RUBY
+
+  @terminal.run(%{ruby -rrubygems -rthread -e "#{load_rails.gsub("\"", "\\\"").strip!}" #{rails_create_command} rails_root})
+  if rails_root_exists?
+    @terminal.echo("Generated a Rails #{version_string} application")
+  else
+    raise "Unable to generate a Rails application:\n#{@terminal.output}"
+  end
+  require_thread if rails30?
+end
+
+When /^I configure my application to require the "([^\"]*)" gem(?: with version "(.+)")?$/ do |gem_name, version|
+  bundle_gem(gem_name, version)
+end
+
+When /^I setup mongodb_logger tests$/ do
+  copy_tests
+  add_routes
+end
+
+Then /^the tests should have run successfully$/ do
+  bundle_gem("therubyracer", nil) if rails31?
+  step %{I run "bundle install"}
+  @terminal.status.exitstatus.should == 0
+  step %{I run "rake db:create db:migrate RAILS_ENV=test --trace"}
+  @terminal.status.exitstatus.should == 0
+  step %{I run "rake test RAILS_ENV=test --trace"}
+  @terminal.status.exitstatus.should == 0
+end
+
+When /^I run "([^\"]*)"$/ do |command|
+  @terminal.cd(rails_root)
+  @terminal.run(command)
+end