winston_mongodb_rails 0.0.1

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Alastair Brunton
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,24 @@
+# Winston Mongodb Rails
+
+Initial alpha release, still tied to a rails application config. There are no test, and some tight coupling deep in the code. 
+Hopefully this should be improved in later releases.
+
+
+## Installation
+
+Add the gem to your Gemfile
+
+    gem 'winston_mongodb_rails'
+    
+Add `config/initializers/mongo_logger.rb`
+
+    app_config = Rails.application.config
+    Mog = WinstonMongodbRails::MongoLogger.create_logger(app_config, ((app_config.paths.log.to_a rescue nil) || app_config.paths['log']).first)
+    
+## Usage
+
+    Mog.error "This is an error", object_to_inspect
+    Mog.debug "Debug message"
+    Mog.info "Info message"
+    
+

data/lib/winston_mongodb_rails/mongo_database.rb

@@ -0,0 +1,101 @@
+class MongoDatabase
+  
+  attr_reader :connection
+  
+  def initialize(options = {})
+
+    if ['production', 'staging'].include? Rails.env
+
+      @connection = Mongo::ReplSetConnection.new(APP_CONFIG['replicaset'], :read => :secondary, :name => APP_CONFIG['replicaset_name'])
+      @connection.add_auth(APP_CONFIG['database'], APP_CONFIG['username'], APP_CONFIG['password'])
+      @connection.add_auth('admin', APP_CONFIG['username'], APP_CONFIG['password'])
+    else
+      # if APP_CONFIG['username']
+        # url = "mongodb://#{APP_CONFIG['username']}:#{APP_CONFIG['password']}@#{APP_CONFIG['host']}/#{APP_CONFIG['database']}"
+      # else
+        # url = "mongodb://#{APP_CONFIG['host']}"
+      # end
+      url = "mongodb://#{APP_CONFIG['host']}"
+      @connection = Mongo::Connection.from_uri(url)
+    end
+
+  end
+
+  def all
+    @connection.database_names
+  end
+
+  def collections(database_name)
+    db = @connection.db(database_name)
+    db.collection_names
+  end
+
+  def distinct(database, collection, field)
+    db = @connection.db(database)
+    coll = db.collection(collection)
+    coll.distinct(field.to_s)
+  end
+
+
+  def records(database, collection, last = Time.now)
+        
+    db = @connection.db(database)
+    coll = db.collection(collection)
+
+    if row = coll.find().sort("_id", -1).limit(1).first
+      keys = row.keys
+      if keys.include?('updated_at')
+        find_options = {"updated_at" => {"$lt" => last}}
+        sort_options = [['updated_at', 'descending']]
+
+      elsif keys.include?('created_at')
+        find_options = {"created_at" => {"$lt" => last}}
+        sort_options = [['created_at', 'descending']]
+      else
+        find_options = {}
+      end
+    else
+      find_options = {}
+    end
+        
+    query = coll.find(find_options).limit(25)
+
+    if sort_options
+      query.sort(sort_options)
+    else
+      query
+    end
+  end
+
+  # Need to do some sort of skip and last chat.
+  def capped_records(database, collection, conditions, last = Time.now)
+    db = @connection.db(database)
+    coll = db.collection(collection)
+    conditions = conditions.merge({"timestamp" => {"$lt" => last}})
+    coll.find(conditions).sort([["$natural", "-1"]]).limit(50)
+  end
+
+
+  # Need to do some sort of first and last chat.
+  def range_records(database, collection, conditions, first = Time.now, last = Time.now, limit = 2000)
+    db = @connection.db(database)
+    coll = db.collection(collection)
+    conditions = conditions.merge({"timestamp" => {"$lte" => last, "$gte" => first}})
+
+    baseQuery = coll.find(conditions).sort([["$natural", "-1"]]).limit(limit)
+  end
+
+  def find(database, collection, id)
+    db = @connection.db(database)
+    coll = db.collection(collection)
+    coll.find_one(:_id => BSON::ObjectId(id))
+  end
+
+  def update(database, collection, id, params)
+    db = @connection.db(database)
+    coll = db.collection(collection)
+    s_params = params.stringify_keys
+    coll.update({"_id" => BSON::ObjectId(id)}, {"$set" => s_params}, :safe => true)
+  end
+  
+end

data/lib/winston_mongodb_rails/mongo_logger.rb

@@ -0,0 +1,94 @@
+module WinstonMongodbRails
+  class MongoLogger < ActiveSupport::BufferedLogger
+
+    # Aim to rely on the mongodb driver for replicaset chat.
+
+    # Looks for configuration files in this order
+    CONFIGURATION_FILES = ["mongoid.yml", "database.yml"]
+    LOG_LEVEL_SYM = [:debug, :info, :warn, :error, :fatal, :unknown]
+
+    def initialize(options={})
+      path = options[:path] || File.join(Rails.root, "log/#{Rails.env}-mog.log")
+      level = options[:level] || DEBUG
+      @db_configuration = resolve_config
+      internal_initialize
+      super(path, level)
+    rescue => e
+      # should use a config block for this
+      Rails.env.production? ? (raise e) : (puts "Using BufferedLogger due to exception: " + e.message)
+    end
+
+    def add(severity, message = nil, progname = nil, &block)
+      
+      # this writes to mongo
+      mongo_record = {
+        :level => LOG_LEVEL_SYM[severity].to_s,
+        :timestamp => Time.now,
+        :message => message,
+        :application_name => @application_name,
+        :meta => progname
+      }
+
+      insert_log_record(mongo_record, @safe_insert)
+      super
+    end
+
+
+    private
+    # facilitate testing
+    def internal_initialize
+      configure
+      connect
+    end
+
+    def configure
+      @mongo_database_name = @db_configuration['database'] || "logs"
+      @mongo_collection_name = @db_configuration['collection_name'] || "logs"
+      @application_name = @db_configuration['application_name'] || 'default'
+      @safe_insert = @db_configuration['safe_insert'] || false
+    end
+
+    def resolve_config
+      config = {}
+      CONFIGURATION_FILES.each do |filename|
+        config_file = Rails.root.join("config", filename)
+        if config_file.file?
+          config = YAML.load(ERB.new(config_file.read).result)[Rails.env]
+          config = config['mongo'] if config.has_key?('mongo')
+          break
+        end
+      end
+      config
+    end
+    
+    def connect
+      @mongo_connection ||= MongoDatabase.new.connection
+      @logs_database ||= @mongo_connection.db(@mongo_database_name)
+      @logs_collection ||= @logs_database.collection(@mongo_collection_name)
+    end
+    
+    # This inserts a log record into mongodb
+    def insert_log_record(mongo_record, safe=false)
+      @logs_collection.insert(mongo_record, :safe => safe)
+    end
+
+    class << self
+      def create_logger(config, path)
+        level = ActiveSupport::BufferedLogger.const_get(config.log_level.to_s.upcase)
+        logger = MongoLogger.new(:path => path, :level => level)
+        logger.auto_flushing = false if Rails.env.production?
+        logger
+      rescue StandardError => e
+        logger = ActiveSupport::BufferedLogger.new(STDERR)
+        logger.level = ActiveSupport::BufferedLogger::WARN
+        logger.warn(
+        "CentralLogger Initializer 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." + "\n" +
+        e.message + "\n" + e.backtrace.join("\n")
+        )
+        logger
+      end
+    end
+
+  end # class MongoLogger
+end

data/lib/winston_mongodb_rails/version.rb

@@ -0,0 +1,3 @@
+module WinstonMongodbRails
+  VERSION = '0.0.1'
+end

data/lib/winston_mongodb_rails.rb

@@ -0,0 +1,6 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'mongo'
+require 'winston_mongodb_rails/mongo_database'
+require 'winston_mongodb_rails/mongo_logger'
+

data/release_gem.sh

@@ -0,0 +1,5 @@
+#!/bin/zsh
+
+rm *.gem
+gem build winston_mongodb_rails.gemspec
+gem push `ls *.gem`

data/winston_mongodb_rails.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'winston_mongodb_rails/version'
+
+ 
+Gem::Specification.new do |s|
+  s.name        = "winston_mongodb_rails"
+  s.version     = WinstonMongodbRails::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Alastair Brunton"]
+  s.email       = ["info@simplyexcited.co.uk"]
+  s.homepage    = "http://github.com/pyrat/winston_mongodb_rails"
+  s.summary     = "Port of the winston shared mongodb logger for rails."
+  s.description = "This allows many applications to log to a shared mongodb logger. It is useful, if you have many small applications / load balanced applications and you want to treat a log as a first class citizen."
+  
+  s.add_dependency('mongo')
+  
+  s.required_rubygems_version = ">= 1.3.1"
+  s.require_path = 'lib'
+  s.files       = `git ls-files`.split("\n")
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification 
+name: winston_mongodb_rails
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Alastair Brunton
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-09-04 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mongo
+  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
+description: This allows many applications to log to a shared mongodb logger. It is useful, if you have many small applications / load balanced applications and you want to treat a log as a first class citizen.
+email: 
+- info@simplyexcited.co.uk
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- MIT-LICENSE
+- README.md
+- lib/winston_mongodb_rails.rb
+- lib/winston_mongodb_rails/mongo_database.rb
+- lib/winston_mongodb_rails/mongo_logger.rb
+- lib/winston_mongodb_rails/version.rb
+- release_gem.sh
+- winston_mongodb_rails.gemspec
+has_rdoc: true
+homepage: http://github.com/pyrat/winston_mongodb_rails
+licenses: []
+
+post_install_message: 
+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: 25
+      segments: 
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Port of the winston shared mongodb logger for rails.
+test_files: []
+