remexify 1.2.0 → 1.3.0

data/README.md

@@ -1,30 +1,27 @@
 # Remexify
 
-Remexify is the world's simplest Rails-only ActiveRecord gem to write/retrieve logs written into your database's table. 
-Its philosophy is not to be a dictator gem, so you have your control over what to log, the log level, and et cetera. 
-Remexify is happy to be no fluff, and to-the-point!
+Remexify is the simplest way to log anything into your database, build for Rails. It supports ActiveRecord and Mongoid::Document. Remexify is happy to be no fluff, and to-the-point!
 
 ## Behind the scene
 
 > Roses are red violets are blue, a log is not a poem it should be accessible to you.
 
-Remexify is always by my side whenever I need to log something into the database. I am tired of managing different logger,
-or duplicatings codes accross multitude of projects I am working on only to have this kind of ability that I wanted.
-Therefore, I refactor it and made it into a gem available to all projects a bundle away not only for mine, but also for yours. 
-I wish it will help you somehow.
+I always used Remexify whenever I need to log something into the database. I am tired of managing different logger,
+or duplicating codes across projects for getting the simple functionality that I had always wanted to have.
+Therefore, I refactor it, and made it into a gem, so that it become available to all projects a bundle away. 
 
 ## Why should you use Remexify?
 
 Remexify...
 
-1. Help you log to your own database, by giving you the control and ease on when/where to do that.
-2. Let you log not only an error, but also info, log, etc. Actually, "error" is just a numeric constant.
-3. Gives you the flexible means of accessing your logged error.
-4. Let you *censor* specific error classes which you don't want it to appear in the backtrace.
-5. Let you define acceptable/unacceptable classes of error which you can use to control what instance of exception class you want to dismiss, or to keep.
-6. Logs similar error once, but will record the frequency if similar error occurred again.
-7. Can associate your logs to certain user, object, or anything.
-7. Is free and open source for all the People of Earth.
+1. Help you log to your own database, giving you the control and ease on when/where to do that.
+2. Let you log not only an error, but also info, log, etc. (Those info/log/etc definition is just a numeric constant.)
+3. Give you the easy, and flexible mean of accessing your log.
+4. Let you *censor* string in the backtrace so it won't pollute your backtrace from noisy, unnecessary information.
+5. Let you define acceptable/unacceptable classes to be logged.
+6. Logs error once, and increase its occurence frequency so no 2 similar logs are duplicate of each other.
+7. Can associate your logs to certain user, object, or anything in order to trace who trigger the error.
+7. It is free, 100% I contribute it as an open source for all the People of Earth to use it.
 
 ## Installation
 
@@ -40,30 +37,30 @@ Or install it yourself as:
 
     $ gem install remexify
 
+Then, you need to generate some models that the gem needs, here we give our model name of `System::Loggers`:
+
+    rails g remexify System::Loggers
+    
+You can name your log class anything, such as `System::Loggers`. After that, you have to migrate it:
+
+    rake db:migrate
+    
 ## Design Decision
 
-This gem monkey patch attribute already_logged(?) in two standard ruby error classes:
+By using this gem, it will monkey patch `already_logged` into these two classes:
 
 1. RuntimeError
 2. StandardError
  
-`already_logged` (or `already_logged?`) will return nil if the exception is not yet logged.
-
-Additionally, there is new error class `DisplayableError`. DisplayableError will be quite handy if you want to raise an enduser-visible error. In your controller, you may only allow an instance of DisplayableError to be displayed. DisplayableError
-is nothing but a StandardError subclassed.
-
-If Remexify caught exceptions any of the above class, it will mark `already_logged` to `true`. Remexify won't log it again when parent/calling method rescue the error.
+`already_logged` (or `already_logged?`) will return nil if the exception is not yet logged. Additionally, there is new error class 
+`DisplayableError`. You can set apart user-visible error for system-only administrative-level error through the use of
+`DisplayableError`. Thus, in your controller, you may allow only an instance of DisplayableError to be displayed. DisplayableError
+is nothing but a sub-classed StandardError.
 
 ## Basic Usage
 
-To use this gem, you need to generate some files first. You can let the gem to generate all required files, including migration and initializer, for you. To do so, issue:
-
-    rails g remexify System::Loggers
-    
-You can name your log class anything, such as `System::Loggers`. After that, you have to migrate it.
+### Logging
 
-    rake db:migrate
-    
 Finally, you can use the gem!
 
     Remexify.log err
@@ -77,16 +74,23 @@ In a rails app, you may invoke the `error()` like this:
       Remexify.error e, file: __FILE__, class: self.class.name, method: __method__, line: __LINE__
       raise e
     end 
-            
-Remexify have 4 static functions:
+
+Starting from version 1.2.0, you can omit `file`, `method`, and `line` from the hash, which the gem will try to deduct by itself.
+
+```ruby
+      Remexify.error e, class: self.class.name
+```
+
+Instead of `error`, Remexify also provide you with other handy method for logging, those are:
 
     def write(level, obj, options = {}); end;
     def info(obj, options = {}); end;
     def warning(obj, options = {}); end;
     def error(obj, options = {}); end;
-    
-`write()` is the most basic function, that you will only need to use if you want to define the level yourself.
-Some level is predefined:
+
+You may define your own level, if you are not satisfied with the already-given `info`, `warning`, and `error`. To do so,
+you will utilise the `write` function. Actually, `write` is the basic function on which the 3 functions above depend on.
+An error, a warning or an info in Remexify is just a constant:
 
     INFO = 100
     WARNING = 200
@@ -94,21 +98,39 @@ Some level is predefined:
 
 Thus, if you want to write info log by invoking `info()` then the log will be recorded with level set to 100.
 
-The obj can be any object. You can pass it a(n instance of) `String`, or an `Exception`, `StandardError`, `RuntimeError`, `DisplayableError`.
+```ruby
+def info(message_object, options = {})
+  write INFO, message_object, options
+end
+```
+
+The obj can be any object. You can pass it a `String`, or an `Exception`, `StandardError`, `RuntimeError`, `DisplayableError`.
 
 It will **automatically generate the backtrace if the object passed is an exception.**
 
-Options can have:
 
-1. :method
-2. :line
-3. :file
-4. :parameters
-5. :description
+### Accepted options for logging
+
+Options accepts those parameters:
+
+| Option               | Optional? | Description                                                                                                   |
+|----------------------|-----------|---------------------------------------------------------------------------------------------------------------|
+| :class               | N         | The class that triggers the error                                                                             |
+| :method              | Y         | The method that triggers the error                                                                            |
+| :line                | Y         | The line the error is triggered                                                                               |
+| :file                | Y         | The file the error is triggered                                                                               |
+| :params              | Y         | Additional information (such as query parameters) that may help later on in an effort to replicate the error. |
+| :desc                | Y         | Description of the error                                                                                      |
+| :extract_params_from | Y         | Specify an ActiveRecord model instance, and all of its attributes will be logged as `params`                  |
+| :owned_by            | Y         | Associate the error to certain entity                                                                         |
+| :owned_param1        | Y         | Further discrimination of owner                                                                               |
+| :owned_param2        | Y         | Further discrimination of owner                                                                               |
+| :owned_param3        | Y         | Further discrimination of owner                                                                               |
+| :object              | Y         | Object of an ActiveRecord model, snatch information about why the error occur if such an information exist.   |
 
-All those options are optional, and, if given, will be stored in the database.
+#### Retrieving logs
 
-In order to retrieve the recorded logs, you will deal with Remexify's Retrieve module. You may retrieve all logs:
+You will need to deal with an extremely simple Remexify's `Retrieve` module. You may retrieve all logs:
 
     Remexify::Retrieve.all
     
@@ -128,7 +150,7 @@ You may also delete all the logs in your database:
 
     Remexify.delete_all_logs
 
-## What is recorded in the database?
+### What is recorded in the database?
 
 These are the fields that is recorded:
 
@@ -289,4 +311,7 @@ by Adam Pahlevi Baihaqi
   - User can configure `accepted_exceptions`
   - User can configure `discarded_exceptions`
   - Ability to associate log to specific user
-  - Ability to retrieve logs that owned by certain identifier_id (like, user's id)
+  - Ability to retrieve logs that owned by certain identifier_id (like, user's id)
+  - You are no longer required to specify `file`, `class` and `method` as Remexify now is able to deduct such infomation from the calling trace.
+- [v.1.3.0](#)
+  - Added support for Mongoid::Document

data/lib/generators/{remexify_generator.rb → active_record/remexify_generator.rb}

@@ -1,17 +1,12 @@
-require "rails/generators"
+require "rails/generators/active_record"
 require "rails/generators/migration"
-require "rails/generators/named_base"
 
-module Remexify
+module ActiveRecord
   module Generators
-    class RemexifyGenerator < Rails::Generators::NamedBase
+    class RemexifyGenerator < ActiveRecord::Generators::Base
       include Rails::Generators::Migration
       source_root File.expand_path("../templates", __FILE__)
 
-      desc "Generates a model with the given NAME for remexify to log error/informations"
-
-      namespace "remexify"
-
       # to avoid next migration numbers having the same exact identity
       @secondth = 1
 
@@ -20,11 +15,13 @@ module Remexify
         (Time.now.utc. + @secondth).strftime("%Y%m%d%H%M%S")
       end
 
+      # copy the migration
       def copy_migration
         migration_template "create_remexify_lognotes.rb", "db/migrate/create_remexify_lognotes.rb"
         migration_template "create_remexify_logowners.rb", "db/migrate/create_remexify_logowners.rb"
       end
 
+      # generate appropriate model
       def generate_model
         # don't just call invoke without Rails::Generators because Thor task only run once.
         Rails::Generators.invoke "active_record:model", [name, "--no-migration"]

data/lib/generators/{templates → active_record/templates}/create_remexify_lognotes.rb

@@ -4,7 +4,7 @@ class CreateRemexifyLognotes < ActiveRecord::Migration
       # 0 the more high the level, the more important.
       t.integer :level, null: false, default: 0
 
-      # let your log unique
+      # let your log be unique
       t.string :md5, null: false
 
       t.text :message, null: false

data/lib/generators/mongoid/remexify_generator.rb

@@ -0,0 +1,74 @@
+require "rails/generators/named_base"
+
+module Mongoid
+  module Generators
+    class RemexifyGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path("../templates", __FILE__)
+
+      def generate_log_model
+        Rails::Generators.invoke "mongoid:model", [name]
+      end
+
+      def generate_logowner_model
+        Rails::Generators.invoke "mongoid:model", ["#{name}Owners"]
+      end
+
+      def inject_log_model
+        log_data = <<RUBY
+  include Mongoid::Timestamps::Short
+
+  # 0; the more high the level, the more important
+  field :level,       type: Integer, default: 0
+
+  # let your log be unique
+  field :md5,         type: String
+
+  field :message,     type: String
+  field :backtrace,   type: String
+  field :file_name,   type: String
+
+  field :class_name,  type: String
+  field :method_name, type: String
+  field :line,        type: String
+
+  # additional parameters that want to be logged as well
+  field :parameters,  type: String
+
+  # additional description that want to be logged as well
+  field :description, type: String
+
+  # how many times the system logging this error?
+  field :frequency,   type: Integer, default: 1
+
+  validates_presence_of :level, :md5, :message, :class_name, :frequency
+  index({ md5: 1 }, {unique: true})
+RUBY
+
+        inject_into_file File.join("app", "models", "#{file_path}.rb"), log_data, after: "include Mongoid::Document\n"
+      end
+
+      def inject_logowner_model
+        log_data = <<RUBY
+  include Mongoid::Timestamps::Short
+
+  field :log_md5,       type: String
+  field :identifier_id, type: String
+
+  field :param1,        type: String
+  field :param2,        type: String
+  field :param3,        type: String
+
+  validates_presence_of :log_md5, :identifier_id
+
+  index({ md5: 1, identifier_id: 1 }, { unique: true })
+RUBY
+        inject_into_file File.join("app", "models", "#{file_path}_owners.rb"), log_data, after: "include Mongoid::Document\n"
+      end
+
+      def make_initializer
+        template "initialize_remexify.rb", "config/initializers/00_remexify.rb"
+      end
+
+    end
+  end
+end

data/lib/generators/mongoid/templates/initialize_remexify.rb

@@ -0,0 +1,8 @@
+Remexify.setup do |config|
+  config.model = <%= class_name %>
+  config.model_owner = <%= class_name %>Owners
+
+  # uncomment lines bellow if you want to out list mongoid. add other similar lines
+  # for other libraries if you wish.
+  config.censor_strings << "mongoid"
+end

data/lib/generators/remexify/remexify_generator.rb

@@ -0,0 +1,13 @@
+require "rails/generators"
+require "rails/generators/named_base"
+
+module Remexify
+  module Generators
+    class RemexifyGenerator < Rails::Generators::NamedBase
+      namespace "remexify"
+      desc "Generates a model with the given NAME for remexify to log error/informations"
+
+      hook_for :orm
+    end
+  end
+end

data/lib/remexify.rb

@@ -36,7 +36,19 @@ module Remexify
       end
 
       # model must exists as ActiveRecord model. model_owner is not necessary to exists at all
-      raise "Remexify.config.model is not an ActiveRecord model" unless config.model < ActiveRecord::Base
+      if defined?(ActiveRecord::Base) && defined?(Mongoid::Document)
+        if (config.model < ActiveRecord::Base) || (config.model < Mongoid::Document)
+          # good!
+        else
+          raise "Remexify.config.model is neither an ActiveRecord model or Mongoid::Document"
+        end
+      elsif defined?(ActiveRecord::Base)
+        raise "Remexify.config.model is not an ActiveRecord model" unless config.model < ActiveRecord::Base
+      elsif defined?(Mongoid::Document)
+        raise "Remexify.config.model is not a Mongoid::Document" unless config.model < Mongoid::Document
+      else
+        raise "Remexify.config.model is neither an ActiveRecord model or Mongoid::Document"
+      end
     end
   end
 

data/lib/remexify/remexify_writer.rb

@@ -39,6 +39,8 @@ module Remexify
         backtrace = ""
       end
 
+      backtrace = "null" if backtrace.blank?
+
       # standardize into options[:parameters]
       options[:parameters] = options[:param] if options[:param]
       options[:parameters] = options[:params] if options[:params]
@@ -48,24 +50,43 @@ module Remexify
       # will override the options[:parameters] if this block execute successfully
       if options[:extract_params_from]
         ar_message_objectect = options[:extract_params_from]
-        if ar_message_objectect.class < ActiveRecord::Base
-          if ar_message_objectect.respond_to?(:attribute_names) && ar_message_objectect.respond_to?(:read_attribute)
-            ar_attributes = ar_message_objectect.attribute_names
-            attributes = {}
+
+        def parse_model_fields model
+          attributes = {}
+          if model.respond_to?(:attribute_names) && model.respond_to?(:read_attribute)
+            ar_attributes = model.attribute_names
             ar_attributes.each do |attr|
-              attributes[attr.to_s] = ar_message_objectect.read_attribute attr.to_sym
+              attributes[attr.to_s] = model.read_attribute attr.to_sym
             end
             options[:parameters] = attributes
           end
+          attributes
+        end
+
+        if defined?(ActiveRecord::Base)
+          options[:parameters] = parse_model_fields(ar_message_objectect) if ar_message_objectect.class < ActiveRecord::Base
+        end
+
+        if defined?(Mongoid::Document)
+          options[:parameters] = parse_model_fields(ar_message_objectect) if ar_message_objectect.class < Mongoid::Document
         end
       end
 
       # if object is given
       if options[:object]
-        # and is an active record
-        if options[:object].class < ActiveRecord::Base
+        parse_error_messages = false
+        # and is an active record/mongoid document
+        if defined?(ActiveRecord::Base)
+          parse_error_messages = true if options[:object].class < ActiveRecord::Base
+        end
+
+        if defined?(Mongoid::Document)
+          parse_error_messages = true if options[:object].class < Mongoid::Document
+        end
+
+        if parse_error_messages
           # append to message
-          message << "\n\nActiveRecord error messages:\n" << options[:object].errors.full_messages.join("\n")
+          message << "\n\nerror messages:\n" << options[:object].errors.full_messages.join("\n")
         end
       end
 
@@ -85,7 +106,7 @@ module Remexify
       # do not quote md5 directly, it is used to query .where
       md5 = Digest::MD5.hexdigest hashed
       # the quoted version of md5, do not replace the original value
-      qmd5 = config.model.connection.quote md5
+      qmd5 = md5
 
       # assure md5 is not yet exist, if exist, don't save
       log = config.model.where(md5: md5).first
@@ -93,9 +114,7 @@ module Remexify
         log.frequency += 1
         log.save
       else
-        message = config.model.connection.quote message
-        backtrace = backtrace.blank? ? "null" : config.model.connection.quote(backtrace)
-        class_name = config.model.connection.quote(class_name)
+
 
         method = line = file = "null"
         if Kernel.respond_to? :caller_locations
@@ -109,28 +128,58 @@ module Remexify
           line = options[:line] unless options[:line].blank?
           file = options[:file] unless options[:file].blank?
         end
-        method = config.model.connection.quote(method)
-        line = config.model.connection.quote(line)
-        file = config.model.connection.quote(file)
 
-        parameters = options[:parameters].blank? ? "null" : config.model.connection.quote(options[:parameters].inspect)
-        descriptions = options[:description].blank? ? "null" : config.model.connection.quote(options[:description])
-        time_now = config.model.connection.quote(Time.now.strftime("%Y-%m-%d %H:%M:%S"))
+        parameters = options[:parameters].blank? ? "null" : options[:parameters].inspect
+        descriptions = options[:description].blank? ? "null" : options[:description]
+        time_now = Time.now.strftime("%Y-%m-%d %H:%M:%S")
+
+        if defined?(ActiveRecord::Base)
+          if config.model < ActiveRecord::Base
+            if config.model.connection.transaction_open?
+              config.model.connection.rollback_transaction
+            end
 
-        if config.model.connection.transaction_open?
-          config.model.connection.rollback_transaction
+            qmd5 = config.model.connection.quote md5
+            message = config.model.connection.quote message
+            backtrace = config.model.connection.quote backtrace
+            class_name = config.model.connection.quote class_name
+            method = config.model.connection.quote method
+            line = config.model.connection.quote line
+            file = config.model.connection.quote file
+            parameters = config.model.connection.quote parameters
+            descriptions = config.model.connection.quote parameters
+            time_now = config.model.connection.quote time_now
+
+            ActiveRecord::Base.transaction do
+              config.model.connection.execute <<-SQL
+              INSERT INTO #{config.model.table_name} (
+               md5, level, message, backtrace,
+               class_name, method_name, line, file_name,
+               parameters, description, created_at, updated_at)
+              VALUES (#{qmd5}, #{Integer level}, #{message}, #{backtrace}, #{class_name},
+               #{method}, #{line}, #{file}, #{parameters}, #{descriptions},
+               #{time_now}, #{time_now});
+              SQL
+            end
+          end
+        elsif defined?(Mongoid::Document)
+          if config.model < Mongoid::Document
+            new_log = config.model.new
+            new_log.md5 = qmd5
+            new_log.level = Integer(level)
+            new_log.message = message
+            new_log.backtrace = backtrace
+            new_log.class_name = class_name
+            new_log.method_name = method
+            new_log.line = line
+            new_log.file_name = file
+            new_log.parameters = parameters
+            new_log.description = descriptions
+            new_log.created_at = time_now
+            new_log.updated_at = time_now
+            new_log.save
+          end
         end
-        config.model.connection.begin_transaction
-        config.model.connection.execute <<-SQL
-          INSERT INTO #{config.model.table_name} (
-           md5, level, message, backtrace,
-           class_name, method_name, line, file_name,
-           parameters, description, created_at, updated_at)
-          VALUES (#{qmd5}, #{Integer level}, #{message}, #{backtrace}, #{class_name},
-           #{method}, #{line}, #{file}, #{parameters}, #{descriptions},
-           #{time_now}, #{time_now});
-        SQL
-        config.model.connection.commit_transaction
       end
 
       # mark already logged if DisplayableError
@@ -139,19 +188,38 @@ module Remexify
       end
 
       # if owner_by is given, associate this log to the owned_by user
-      if !options[:owned_by].blank? && (config.model_owner < ActiveRecord::Base)
-        owned_by = config.model.connection.quote(options[:owned_by])
-        owned_param1 = config.model.connection.quote(options[:owned_param1])
-        owned_param2 = config.model.connection.quote(options[:owned_param2])
-        owned_param3 = config.model.connection.quote(options[:owned_param3])
-
-        config.model.connection.begin_transaction
-        config.model.connection.execute <<-SQL
-          INSERT INTO #{config.model_owner.table_name} (
-           log_md5, identifier_id, param1, param2, param3)
-           VALUES (#{qmd5}, #{owned_by}, #{owned_param1}, #{owned_param2}, #{owned_param3})
-        SQL
-        config.model.connection.commit_transaction
+      unless options[:owned_by].blank?
+        owned_by = options[:owned_by]
+        owned_param1 = options[:owned_param1]
+        owned_param2 = options[:owned_param2]
+        owned_param3 = options[:owned_param3]
+
+        if defined?(ActiveRecord::Base)
+          if config.model_owner < ActiveRecord::Base
+            owned_by = config.model.connection.quote(owned_by)
+            owned_param1 = config.model.connection.quote(owned_param1)
+            owned_param2 = config.model.connection.quote(owned_param2)
+            owned_param3 = config.model.connection.quote(owned_param3)
+
+            # config.model.connection.begin_transaction
+            ActiveRecord::Base.transaction do
+              config.model.connection.execute <<-SQL
+                INSERT INTO #{config.model_owner.table_name} (
+                  log_md5, identifier_id, param1, param2, param3)
+                VALUES (#{qmd5}, #{owned_by}, #{owned_param1}, #{owned_param2}, #{owned_param3})
+              SQL
+            end
+            # config.model.connection.commit_transaction
+          end
+        elsif defined?(Mongoid::Document)
+          if config.model_owner < Mongoid::Document
+            log_owner = config.model_owner.new
+            log_owner.owned_by = owned_by
+            log_owner.owned_param1 = owned_param1
+            log_owner.owned_param2 = owned_param2
+            log_owner.owned_param3 = owned_param3
+          end
+        end
       end
 
       nil # don't return anything for logging!