mongodb_logger 0.3.3 → 0.4.0

data/lib/mongodb_logger.rb

@@ -1,6 +1,5 @@
 $:.unshift File.dirname(__FILE__)
 
-require 'mongo'
 require 'mongodb_logger/config'
 require 'mongodb_logger/logger'
 require 'mongodb_logger/railtie' if defined?(Rails::Railtie)
@@ -21,6 +20,10 @@ module MongodbLogger
                    when request.respond_to?(:filtered_parameters) then request.filtered_parameters
                    else params
                  end
+      f_session = case
+                   when request.respond_to?(:session) then request.session
+                   else session
+                 end
       Rails.logger.mongoize({
         :method         => request.method,
         :action         => action_name,
@@ -28,8 +31,9 @@ module MongodbLogger
         :path           => request.path,
         :url            => request.url,
         :params         => f_params,
+        :session        => f_session,
         :ip             => request.remote_ip
       }) { yield }
     end
   end
-end
+end

data/lib/mongodb_logger/adapters.rb

@@ -0,0 +1,3 @@
+require 'mongodb_logger/adapters/base'
+require 'mongodb_logger/adapters/mongo'
+require 'mongodb_logger/adapters/moped'

data/lib/mongodb_logger/adapters/base.rb

@@ -0,0 +1,45 @@
+module MongodbLogger
+  module Adapers
+    class Base
+
+      attr_reader :configuration, :connection, :connection_type, :collection, :authenticated
+
+      def collection_name
+        @configuration['collection']
+      end
+
+      def authenticated?
+        @authenticated
+      end
+
+      def check_for_collection
+        # setup the capped collection if it doesn't already exist
+        create_collection unless @connection.collection_names.include?(@configuration['collection'])
+        @collection = @connection[@configuration['collection']]
+      end
+
+      def reset_collection
+        if @connection && @collection
+          @collection.drop
+          create_collection
+        end
+      end
+      
+      def collection_stats_hash(stats)
+        {
+          :is_capped => (stats["capped"] && ([1, true].include?(stats["capped"]))),
+          :count => stats["count"].to_i,
+          :size => stats["size"].to_f,
+          :storageSize => stats["storageSize"].to_f,
+          :db_name => @configuration["database"],
+          :collection => collection_name
+        }
+      end
+
+      def create_collection
+        raise "Not implemented"
+      end
+
+    end
+  end
+end

data/lib/mongodb_logger/adapters/mongo.rb

@@ -0,0 +1,91 @@
+module MongodbLogger
+  module Adapers
+    class Mongo < Base
+      
+      def initialize(options = {})
+        @authenticated = false
+        @configuration = options
+        if @configuration['url']
+          uri = URI.parse(@configuration['url'])
+          @configuration['database'] = uri.path.gsub(/^\//, '')
+          @connection ||= mongo_connection_object.db(@configuration['database'])
+          @authenticated = true
+        else
+          @connection ||= mongo_connection_object.db(@configuration['database'])
+          if @configuration['username'] && @configuration['password']
+            # the driver stores credentials in case reconnection is required
+            @authenticated = @connection.authenticate(@configuration['username'],
+                                                          @configuration['password'])
+          end
+        end
+      end
+      
+      def create_collection
+        @connection.create_collection(collection_name,
+          {:capped => true, :size => @configuration['capsize'].to_i})
+      end
+      
+      def insert_log_record(record, options = {})
+        @collection.insert(record, options[:write_options])
+      end
+      
+      def collection_stats
+        collection_stats_hash(@collection.stats)
+      end
+      
+      # filter
+      def filter_by_conditions(filter)
+        @collection.find(filter.get_mongo_conditions).sort('$natural', -1).limit(filter.get_mongo_limit)
+      end
+      
+      def find_by_id(id)
+        @collection.find_one(::BSON::ObjectId(id))
+      end
+      
+      def tail_log_from_params(params = {})
+        logs = []
+        last_id = nil
+        if params[:log_last_id] && !params[:log_last_id].blank?
+          log_last_id = params[:log_last_id]
+          @collection.find({'_id' => { '$gt' => ::BSON::ObjectId(log_last_id) }}).sort('$natural', -1).each do |log|
+            logs << log
+            log_last_id = log["_id"].to_s
+          end
+          logs.reverse!
+        else
+          log = @collection.find_one({}, {:sort => ['$natural', -1]})
+          log_last_id = log["_id"].to_s unless log.blank?
+        end
+        { 
+          :log_last_id => log_last_id, 
+          :time => Time.now.strftime("%F %T"),
+          :logs => logs
+        }
+      end
+      
+      def calculate_mapreduce(map, reduce, params = {})
+        @collection.map_reduce(map, reduce, {:query => params[:conditions], :sort => ['$natural', -1], :out => {:inline => true}, :raw => true}).find()
+      end
+      
+      private
+      
+      def mongo_connection_object
+        if @configuration['hosts']
+          conn = ::Mongo::ReplSetConnection.new(*(@configuration['hosts'] <<
+            {:connect => true, :pool_timeout => 6}))
+          @configuration['replica_set'] = true
+        elsif @configuration['url']
+          conn = ::Mongo::Connection.from_uri(@configuration['url'])
+        else
+          conn = ::Mongo::Connection.new(@configuration['host'],
+                                       @configuration['port'],
+                                       :connect => true,
+                                       :pool_timeout => 6)
+        end
+        @connection_type = conn.class
+        conn
+      end
+      
+    end
+  end
+end

data/lib/mongodb_logger/adapters/moped.rb

@@ -0,0 +1,95 @@
+module MongodbLogger
+  module Adapers
+    class Moped < Base
+      
+      def initialize(options = {})
+        @configuration = options
+        if @configuration['url']
+          uri = URI.parse(@configuration['url'])
+          @configuration['database'] = uri.path.gsub(/^\//, '')
+          @connection ||= mongo_connection_object
+          @connection.use @configuration['database']
+          @authenticated = true
+        else
+          @connection ||= mongo_connection_object
+          @connection.use @configuration['database']
+          if @configuration['username'] && @configuration['password']
+            # the driver stores credentials in case reconnection is required
+            @authenticated = @connection.login(@configuration['username'],
+                                                          @configuration['password'])
+          end
+        end
+      end
+      
+      def create_collection
+        @connection.command(create: collection_name, capped: true, size:  @configuration['capsize'].to_i)
+      end
+      
+      def insert_log_record(record, options = {})
+        record[:_id] = ::Moped::BSON::ObjectId.new
+        @connection.with(safe: options[:write_options])[collection_name].insert(record)
+      end
+
+      def collection_stats
+        collection_stats_hash(@connection.command(collStats: collection_name))
+      end
+      
+      # filter
+      def filter_by_conditions(filter)
+        @collection.find(filter.get_mongo_conditions).sort('$natural' => -1).limit(filter.get_mongo_limit)
+      end
+      
+      def find_by_id(id)
+        @collection.find("_id" => ::Moped::BSON::ObjectId.from_string(id)).first
+      end
+      
+      def tail_log_from_params(params = {})
+        logs = []
+        last_id = nil
+        if params[:log_last_id] && !params[:log_last_id].blank?
+          log_last_id = params[:log_last_id]
+          @collection.find({'_id' => { '$gt' => ::Moped::BSON::ObjectId.from_string(log_last_id) }}).sort('$natural' => -1).each do |log|
+            logs << log
+            log_last_id = log["_id"].to_s
+          end
+          logs.reverse!
+        else
+          log = @collection.find.sort('$natural' => -1).first
+          log_last_id = log["_id"].to_s unless log.blank?
+        end
+        { 
+          :log_last_id => log_last_id, 
+          :time => Time.now.strftime("%F %T"),
+          :logs => logs
+        }
+      end
+      
+      def calculate_mapreduce(map, reduce, params = {})
+        @connection.command(
+          mapreduce: collection_name,
+          map: map,
+          reduce: reduce,
+          query: params[:conditions],
+          out: { inline: true },
+          raw: true
+        ).find()
+      end
+
+      private
+      
+      def mongo_connection_object
+        if @configuration['hosts']
+          conn = ::Moped::Session.new(@configuration['hosts'].map{|(host,port)| "#{host}:#{port}"}, :timeout => 6)
+          @configuration['replica_set'] = true
+        elsif @configuration['url']
+          conn = ::Moped::Session.connect(@configuration['url'])
+        else
+          conn = ::Moped::Session.new(["#{@configuration['host']}:#{@configuration['port']}"], :timeout => 6)
+        end
+        @connection_type = conn.class
+        conn
+      end
+      
+    end
+  end
+end

data/lib/mongodb_logger/logger.rb

@@ -1,10 +1,10 @@
 require 'erb'
 require 'uri'
-require 'mongo'
 require 'active_support'
 require 'active_support/core_ext'
 require 'active_support/core_ext/logger'
 require 'action_dispatch/http/upload'
+require 'mongodb_logger/adapters'
 require 'mongodb_logger/replica_set_helper'
 
 module MongodbLogger
@@ -15,16 +15,21 @@ module MongodbLogger
     # Looks for configuration files in this order
     CONFIGURATION_FILES = ["mongodb_logger.yml", "mongoid.yml", "database.yml"]
     LOG_LEVEL_SYM = [:debug, :info, :warn, :error, :fatal, :unknown]
+    
+    ADAPTERS = [
+      ["mongo", Adapers::Mongo],
+      ["moped", Adapers::Moped]
+    ]
 
-    attr_reader :db_configuration, :mongo_connection, :mongo_collection_name, :mongo_collection, :mongo_connection_type
+    attr_reader :db_configuration, :mongo_adapter
 
-    def initialize(options={})
+    def initialize(options = {})
       path = options[:path] || File.join(Rails.root, "log/#{Rails.env}.log")
       @level = options[:level] || DEBUG
       internal_initialize
     rescue => e
       # should use a config block for this
-      Rails.env.production? ? (raise e) : (puts "MongodbLogger WARNING: Using BufferedLogger due to exception: " + e.message)
+      Rails.env.production? ? (raise e) : (puts "MongodbLogger WARNING: Using BufferedLogger due to exception: #{e.message}")
     ensure
       if disable_file_logging?
         @log            = ::Logger.new(STDOUT)
@@ -34,9 +39,9 @@ module MongodbLogger
       end
     end
 
-    def add_metadata(options={})
+    def add_metadata(options = {})
       options.each do |key, value|
-        unless [:messages, :request_time, :ip, :runtime, :application_name, :is_exception, :params, :method].include?(key.to_sym)
+        unless [:messages, :request_time, :ip, :runtime, :application_name, :is_exception, :params, :session, :method].include?(key.to_sym)
           @mongo_record[key] = value
         else
           raise ArgumentError, ":#{key} is a reserved key for the mongodb logger. Please choose a different key"
@@ -55,19 +60,11 @@ module MongodbLogger
       disable_file_logging? ? message : (@level ? super : message)
     end
 
-    # Drop the capped_collection and recreate it
-    def reset_collection
-      if @mongo_connection && @mongo_collection
-        @mongo_collection.drop
-        create_collection
-      end
-    end
-
-    def mongoize(options={})
+    def mongoize(options = {})
       @mongo_record = options.merge({
         :messages => Hash.new { |hash, key| hash[key] = Array.new },
         :request_time => Time.now.getutc,
-        :application_name => @application_name
+        :application_name => @db_configuration['application_name']
       })
 
       runtime = Benchmark.measure{ yield }.real if block_given?
@@ -97,12 +94,8 @@ module MongodbLogger
       end
     end
 
-    def authenticated?
-      @authenticated
-    end
-
     private
-      # facilitate testing
+
       def internal_initialize
         configure
         connect
@@ -115,26 +108,21 @@ module MongodbLogger
 
       def configure
         default_capsize = DEFAULT_COLLECTION_SIZE
-        @authenticated = false
         @db_configuration = {
           'host' => 'localhost',
           'port' => 27017,
           'capsize' => default_capsize}.merge(resolve_config)
-        @mongo_collection_name = @db_configuration['collection'] || "#{Rails.env}_log"
-        @application_name = resolve_application_name
-        @safe_insert = @db_configuration['safe_insert'] || false
+        @db_configuration['collection'] ||= defined?(Rails) ? "#{Rails.env}_log" : "production_log"
+        @db_configuration['application_name'] ||= resolve_application_name
+        @db_configuration['write_options'] ||= { w: 0, wtimeout: 200 }
 
         @insert_block = @db_configuration.has_key?('replica_set') && @db_configuration['replica_set'] ?
-          lambda { rescue_connection_failure{ insert_log_record(@safe_insert) } } :
-          lambda { insert_log_record }
+          lambda { rescue_connection_failure{ insert_log_record(@db_configuration['write_options']) } } :
+          lambda { insert_log_record(@db_configuration['write_options']) }
       end
 
       def resolve_application_name
-        if @db_configuration.has_key?('application_name')
-          @db_configuration['application_name']
-        else
-          Rails.application.class.to_s.split("::").first
-        end
+        Rails.application.class.to_s.split("::").first if defined?(Rails)
       end
 
       def resolve_config
@@ -149,52 +137,32 @@ module MongodbLogger
         end
         config
       end
-
-      def mongo_connection_object
-        if @db_configuration['hosts']
-          conn = Mongo::ReplSetConnection.new(*(@db_configuration['hosts'] <<
-            {:connect => true, :pool_timeout => 6}))
-          @db_configuration['replica_set'] = true
-        elsif @db_configuration['url']
-          conn = Mongo::Connection.from_uri(@db_configuration['url'])
-        else
-          conn = Mongo::Connection.new(@db_configuration['host'],
-                                       @db_configuration['port'],
-                                       :connect => true,
-                                       :pool_timeout => 6)
-        end
-        @mongo_connection_type = conn.class
-        conn
-      end
-
-      def connect
-        if @db_configuration['url']
-          uri = URI.parse(@db_configuration['url'])
-          @mongo_connection ||= mongo_connection_object.db(uri.path.gsub(/^\//, ''))
-          @authenticated = true
-        else
-          @mongo_connection ||= mongo_connection_object.db(@db_configuration['database'])
-          if @db_configuration['username'] && @db_configuration['password']
-            # the driver stores credentials in case reconnection is required
-            @authenticated = @mongo_connection.authenticate(@db_configuration['username'],
-                                                          @db_configuration['password'])
+      
+      def find_adapter
+        ADAPTERS.each do |(library, adapter)|
+          begin
+            require library
+            return adapter
+          rescue LoadError
+            next
           end
         end
+        return nil
       end
 
-      def create_collection
-        @mongo_connection.create_collection(@mongo_collection_name,
-                                            {:capped => true, :size => @db_configuration['capsize'].to_i})
+      def connect
+        adapter = find_adapter
+        raise "!!! MongodbLogger not found supported adapter. Please, add mongo with bson_ext gems or moped gem into Gemfile !!!" if adapter.nil?
+        @mongo_adapter ||= adapter.new(@db_configuration)
+        @db_configuration = @mongo_adapter.configuration
       end
 
       def check_for_collection
-        # setup the capped collection if it doesn't already exist
-        create_collection unless @mongo_connection.collection_names.include?(@mongo_collection_name)
-        @mongo_collection = @mongo_connection[@mongo_collection_name]
+        @mongo_adapter.check_for_collection
       end
 
-      def insert_log_record(safe = false)
-        @mongo_collection.insert(@mongo_record, :safe => safe)
+      def insert_log_record(write_options)
+        @mongo_adapter.insert_log_record(@mongo_record, write_options: write_options)
       end
 
       def logging_colorized?
@@ -228,8 +196,8 @@ module MongodbLogger
             data.map{|v| nice_serialize_object(v) }
           when ActionDispatch::Http::UploadedFile, Rack::Test::UploadedFile # uploaded files
             hvalues = {
-              :original_filename => data.original_filename,
-              :content_type => data.content_type
+              original_filename: data.original_filename,
+              content_type: data.content_type
             }
           else
             data.inspect