active-audit 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e1fca837bb3e2d692f664310ebe1beffad3484bd
+  data.tar.gz: a7f74a56a41b4443b00de87699df32bef7278d48
+SHA512:
+  metadata.gz: 5cc11c9ece3877bac607d8083b56bf40e649a929c91768abe22174cdf32527b93c60bc4c917d6e529f79e704957cbd0fc509b27061c3608dba2cc82938fbe8e6
+  data.tar.gz: 9d089b1ac422adf173792fa6a4ae1c326c9bc62cbf1d951bdda6bb9ea9ae92bd811add470032b166530606dd12718316b2f53870ff5c91d2d7f52d3e287af24b

data/lib/active-audit.rb

@@ -0,0 +1,34 @@
+require 'active_support'
+require 'active_audit/audit_repository'
+
+module ActiveAudit
+  extend ActiveSupport::Autoload
+
+  eager_autoload { autoload :Base }
+  autoload :StorageAdapters
+
+  class << self
+
+    attr_accessor :storage_adapter, :current_user_method, :ignored_attributes, :job_queue, :delayed_auditing, :default_user, :extract_user_profile
+
+    def configure
+      @current_user_method = :current_user
+      @ignored_attributes = %w(created_at updated_at)
+      @job_queue = :audits
+      @delayed_auditing = false
+      @extract_user_profile = lambda { |user| { id: user.id } }
+      self.eager_load!
+      yield(self) if block_given?
+      AuditRepository.storage_adapter = storage_adapter if storage_adapter
+    end
+
+    def session
+      Thread.current[:auditing_store] ||= {}
+    end
+
+    def add_hint comment
+      self.session[:comment] = comment
+    end
+  end
+
+end

data/lib/active_audit/audit.rb

@@ -0,0 +1,83 @@
+require 'rails/observers/active_model/active_model'
+require 'active_model'
+require 'virtus'
+
+module ActiveAudit
+  class Audit
+    include Virtus.model
+
+    extend  ActiveModel::Callbacks
+    define_model_callbacks :create, :save
+
+    include ActiveModel::Observing
+
+    attribute :item_id, Integer
+    attribute :event, String
+    attribute :type, String
+    attribute :changes, Hash
+    attribute :user, Hash, default: lambda {|o,a| ActiveAudit.default_user }
+    attribute :comment, String
+    attribute :recorded_at, Time, default: lambda { |o,a| Time.now.utc }
+
+    before_save do
+      self.recorded_at = Time.at(self.recorded_at) if self.recorded_at.is_a? Integer
+      self.user = ActiveAudit.extract_user_profile.call(self.user) unless self.user.nil? || self.user.is_a?(Hash)
+    end
+
+    def initialize *args
+      attributes = args.extract_options!
+      if attributes.empty?
+        if args.count == 2
+          initialize_from_record(*args)
+        else
+          raise ArgumentError, "You need to supply at least one attribute"
+        end
+      else
+        super attributes
+      end
+    end
+
+    private def initialize_from_record event, record
+      if event == 'update'
+        if record.respond_to?(:aasm) && record.aasm.current_event
+          event = record.aasm.current_event.to_s.sub(/!$/, '')
+        end
+        self.changes = record.previous_changes.select { |key, value| record.class.auditing_options[:only].include? key }
+        self.changes.merge!(record.association_previous_changes.select { |key, value| record.class.auditing_options[:associations].include? key })
+        self.changes = self.changes.map do |key, values|
+          if values.any? { |v| v.is_a?(Time) }
+            [key, values.map { |x| x && x.utc.iso8601 }]
+          else
+            [key, values]
+          end
+        end.to_h
+      end
+      self.event = event
+      self.type = record.class.auditing_options[:type]
+      self.item_id = record.id
+      set_default_attributes
+    end
+
+    def changed?
+      ['create', 'destroy'].include?(self.event) || changes.present?
+    end
+
+    def save options={}
+      self.run_callbacks :save do
+        yield if changed?
+      end
+    end
+
+    def self.create(attributes, options={})
+      object = self.new(attributes)
+      object.run_callbacks :create do
+        object.save(options)
+        object
+      end
+    end
+
+    def serialize
+      self.attributes.select {|k,v| v.present?}.merge(recorded_at: self.recorded_at.to_i, type: self.type)
+    end
+  end
+end

data/lib/active_audit/audit_pusher.rb

@@ -0,0 +1,10 @@
+module ActiveAudit
+  class AuditPusher < ActiveJob::Base
+    queue_as ActiveAudit.job_queue
+
+    def perform *args
+      AuditRepository.create(args[0])
+    end
+
+  end
+end

data/lib/active_audit/audit_repository.rb

@@ -0,0 +1,38 @@
+module ActiveAudit
+  class AuditRepository
+    class << self
+      def storage_adapter=(repo_name)
+        @@storage_adapter = load_adapter(repo_name)
+      end
+
+      def storage_adapter
+        @@storage_adapter ||= ActiveAudit::StorageAdapters::TestAdapter
+      end
+
+      def find_by_record record, options={}
+        storage_adapter.find_by_record(record, options)
+      end
+
+      def create attributes
+        save Audit.new(attributes)
+      end
+
+      def save audit
+        audit.save do
+          storage_adapter.save audit
+        end
+      end
+
+      private
+        def load_adapter name
+          config = \
+            begin
+              Rails.application.config_for(:active_audit)
+            rescue RuntimeError
+              {}
+            end
+          return "ActiveAudit::StorageAdapters::#{name.to_s.camelize}Adapter".constantize.new config
+        end
+    end
+  end
+end

data/lib/active_audit/base.rb

@@ -0,0 +1,82 @@
+require 'active_audit/errors'
+require 'active_audit/audit'
+require 'active_audit/audit_pusher'
+require 'active_audit/dirty_association'
+require 'active_audit/sweeper'
+
+module ActiveAudit
+  module Base
+    extend ActiveSupport::Concern
+    include DirtyAssociation
+
+    class_methods do
+
+      def auditing_options
+        @auditing_options ||= {
+          type: self.to_s.underscore,
+          only: self.attribute_names - ActiveAudit.ignored_attributes
+        }
+      end
+
+      def audit *args
+        options = args.extract_options!.dup
+        options.assert_valid_keys(:type, :except, :associations, :unless)
+        options[:type] = options[:type].to_s if options[:type]
+        except = options[:except] ? options[:except].map(&:to_s) : []
+        only = if args.present? then args.map(&:to_s) else auditing_options[:only] end
+        options[:only] = only - except
+        if options[:associations]
+          options[:associations] = options[:associations].map(&:to_s)
+          stain *options[:associations]
+        end
+        auditing_options.update options
+      end
+
+    end
+
+    included do
+      if self < ActiveRecord::Base
+        after_commit on: [:create] { write_audit('create') }
+        after_commit on: [:update] { write_audit('update') }
+        after_commit on: [:destroy] { write_audit('destroy') }
+      elsif defined?(Mongoid::Document) && self < Mongoid::Document
+        after_create { write_audit('create') }
+        after_update { write_audit('update') }
+        after_destroy { write_audit('destroy') }
+      else
+        raise Errors::UnsupportedModel, "can audit ActiveRecord and Mongoid models only"
+      end
+    end
+
+    def audits options={}
+      AuditRepository.find_by_record self, options
+    end
+
+    private
+      def audited?
+        if condition = self.class.auditing_options[:unless]
+          case condition
+            when Symbol, String
+              self.public_send condition
+            when Proc
+              condition.call self
+          end
+        end
+        return true
+      end
+
+      def write_audit event
+        if audited?
+          audit = Audit.new event, self
+          if audit.changed?
+            if ActiveAudit.delayed_auditing
+              AuditPusher.perform_later audit.serialize
+            else
+              AuditRepository.save(audit)
+            end
+          end
+        end
+      end
+
+  end
+end

data/lib/active_audit/dirty_association.rb

@@ -0,0 +1,95 @@
+require 'active_support/hash_with_indifferent_access'
+
+module ActiveAudit
+  module DirtyAssociation
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def stain *association_names
+        association_names.each do |association_name|
+          if reflection = _reflect_on_association(association_name)
+            if reflection.collection? && through_refl = reflection.try(:through_reflection)
+              through_id = reflection.foreign_key
+              through_name = through_refl.name
+              define_association_method_suffix association_name
+              ActiveRecord::Associations::Builder::CollectionAssociation.define_callback(self, :after_add, through_name, before_add: lambda do |model, relation|
+                puts "addubng"
+                puts relation.attributes
+                DirtyAssociation.record_add association_name, model, relation, through_name, through_id
+              end)
+              ActiveRecord::Associations::Builder::CollectionAssociation.define_callback(self, :before_remove, through_name, before_remove: lambda do |model, relation|
+                DirtyAssociation.record_remove association_name, model, relation, through_name, through_id
+              end)
+            else
+              raise ArgumentError, "'#{association_name}' is not a many-to-many association."
+            end
+          else
+            raise ArgumentError, "No association found for name `#{association_name}'. Has it been defined yet?"
+          end
+        end
+      end
+
+
+      private
+        def define_association_method_suffix association_name
+          %w(_changed? _change _was _previously_changed? _previous_change).each do |suffix|
+            self.send :define_method, "#{association_name}#{suffix}" do
+              send "association#{suffix}", association_name
+            end
+          end
+        end
+    end
+
+    attr_reader :association_previous_changes
+
+    def association_changes
+      @association_changes ||= ActiveSupport::HashWithIndifferentAccess.new
+    end
+
+    def association_changed? association_name
+      !!association_changes[association_name]
+    end
+
+    def association_change association_name
+      association_changes[association_name]
+    end
+
+    def association_was association_name
+      association_changes[association_name].try '[]', 0
+    end
+
+    def association_previously_changed? association_name
+      !!association_previous_changes[association_name]
+    end
+
+    def association_previous_change association_name
+      association_previous_changes[association_name]
+    end
+
+    def changes_applied
+      super
+      @association_previous_changes = association_changes
+      @association_changes = ActiveSupport::HashWithIndifferentAccess.new
+    end
+
+    module_function
+      def init_association_change association_name, model, through, attribute
+        old_attributes = model.send(through).map {|r| r.send attribute }
+        model.association_changes[association_name] = [old_attributes, old_attributes.dup]
+      end
+
+      def record_add association_name, model, relation, through, attribute
+        unless model.association_changes[association_name]
+          init_association_change association_name, model, through, attribute
+        end
+        model.association_changes[association_name][1].push relation.send(attribute)
+      end
+
+      def record_remove association_name, model, relation, through, attribute
+        unless model.association_changes[association_name]
+          init_association_change association_name, model, through, attribute
+        end
+        model.association_changes[association_name][1].delete relation.send(attribute)
+      end
+  end
+end

data/lib/active_audit/errors.rb

@@ -0,0 +1,5 @@
+module ActiveAudit
+  module Errors
+    class UnsupportedModel < StandardError; end
+  end
+end

data/lib/active_audit/storage_adapters/active_record_adapter.rb

@@ -0,0 +1,28 @@
+module ActiveAudit
+  module StorageAdapters
+    class ActiveRecordAdapter
+
+      def initialize options={}
+        @connection = ::ActiveRecord::Base.connection
+      end
+
+      def find_by_record record, options={}
+        result = @connection.exec_query "SELECT * FROM audits WHERE item_id=$1 AND type=$2 ORDER BY recorded_at DESC;", nil, [[nil, record.id], [nil,record.class.auditing_options[:type]]]
+        result.map { |attributes| ActiveAudit::Audit.new attributes }
+      end
+
+      def save audit
+        @connection.exec_query('INSERT INTO audits("item_id", "event", "type", "changes", "user_id", "user", "comment", "recorded_at") VALUES ($1,$2,$3,$4,$5,$6,$7,$8);', nil, [
+          [nil, audit.item_id],
+          [nil, audit.event],
+          [nil, audit.type],
+          [nil, audit.changes.to_json],
+          [nil, audit.user[:id]],
+          [nil, audit.user.to_json],
+          [nil, audit.comment],
+          [nil, audit.recorded_at]
+        ])
+      end
+    end
+  end
+end

data/lib/active_audit/storage_adapters/elasticsearch_adapter.rb

@@ -0,0 +1,66 @@
+require 'elasticsearch/persistence'
+
+module ActiveAudit
+  module StorageAdapters
+    class ElasticsearchAdapter
+      include ::Elasticsearch::Persistence::Repository
+
+      def initialize options={}
+        index  options['index'] || :auditing
+        client ::Elasticsearch::Client.new url: options['url'] || 'localhost:9200'
+        klass ActiveAudit::Audit
+      end
+
+      type :_default_
+
+      settings do
+        mappings _all: { enabled: false }, date_detection: false, dynamic_templates: [ {
+            strings: {
+              mapping: {
+                index: "not_analyzed",
+                type: "string"
+              },
+              match: "*",
+              match_mapping_type: "string"
+            }
+          } ] do
+          indexes :item_id, type: "long"
+          indexes :event, type: "string", index: "not_analyzed"
+          indexes :changes, type: "object", dynamic: true
+          indexes :user, type: "object", properties: {
+            id: { type: "long" },
+            name: {type: "string", index: "not_analyzed"}
+          }
+          indexes :comment, type: "string", index: "not_analyzed"
+          indexes :recorded_at, type: "date"
+        end
+      end
+
+      def find_by_record record, options={}
+        self.type "#{record.class.auditing_options[:type]}_events"
+        query = {
+          query: { filtered: { filter: { bool: { must: [{ term: { item_id: record.id }}]}}}},
+          sort: { recorded_at: { order: "desc" }}
+        }
+        if options[:from] && options[:to]
+          query[:query][:filtered][:filter][:bool][:must].push range: { recorded_at: { gte: options[:from], lt: options[:to] }}
+        elsif options[:from]
+          query[:query][:filtered][:filter][:bool][:must].push range: { recorded_at: { gte: options[:from] }}
+        elsif options[:to]
+          query[:query][:filtered][:filter][:bool][:must].push range: { recorded_at: { lt: options[:to] }}
+        end
+        if options[:comment]
+          query[:query][:filtered][:filter][:bool][:must].push wildcard: { comment: "*#{options[:comment]}*" }
+        end
+        search(query).to_a
+      end
+
+      define_method :gateway_save, self.new.gateway.method(:save).to_proc
+
+      def save audit
+        self.send :gateway_save, audit, type: "#{audit.type}_events"
+      end
+
+    end
+  end
+end

data/lib/active_audit/storage_adapters/mongo_adapter.rb

@@ -0,0 +1,22 @@
+require 'mongo'
+
+module ActiveAudit
+  module StorageAdapters
+    class MongoAdapter
+
+      def initialize options={}
+        client = ::Mongo::Client.new options['hosts'], options['options'].symbolize_keys
+        @collection = client[:audits]
+      end
+
+      def find_by_record record, options={}
+        result = @collection.find(type: record.class.auditing_options[:type], item_id: record.id)
+        result.map { |audit| ActiveAudit::Audit.new audit.symbolize_keys }
+      end
+
+      def save audit
+        @collection.insert_one(audit.attributes)
+      end
+    end
+  end
+end

data/lib/active_audit/storage_adapters/test_adapter.rb

@@ -0,0 +1,17 @@
+module ActiveAudit
+  module StorageAdapters
+    class TestAdapter
+
+      class << self
+        def find_by_record record, options={}
+          raise NotImplementedError.new "can not retrieve audits with `TestAdapter`."
+        end
+
+        def save audit
+          Rails.logger.info "audit -> #{audit.attributes}"
+        end
+      end
+
+    end
+  end
+end

data/lib/active_audit/storage_adapters.rb

@@ -0,0 +1,10 @@
+module ActiveAudit
+  module StorageAdapters
+    extend ActiveSupport::Autoload
+
+    autoload :ActiveRecordAdapter
+    autoload :ElasticsearchAdapter
+    autoload :MongoAdapter
+    autoload :TestAdapter
+  end
+end

data/lib/active_audit/sweeper.rb

@@ -0,0 +1,55 @@
+require "rails/observers/activerecord/active_record"
+require "rails/observers/action_controller/caching"
+
+module ActiveAudit
+  class Sweeper < ActionController::Caching::Sweeper
+    observe ActiveAudit::Audit
+
+    def around controller
+      begin
+        self.controller = controller
+        self.user = current_user
+        yield
+      ensure
+        self.controller = nil
+        self.user = nil
+      end
+    end
+
+    def before_create audit
+      audit.user = self.user if self.user
+      audit.comment = controller.params[:comment] if controller.respond_to?(:params, true)
+      audit.comment ||= ActiveAudit.session[:comment]
+    end
+
+    def current_user
+      current_user = controller.send(ActiveAudit.current_user_method) if controller.respond_to?(ActiveAudit.current_user_method, true)
+    end
+
+    def controller
+      ActiveAudit.session[:current_controller]
+    end
+
+    def controller=(value)
+      ActiveAudit.session[:current_controller] = value
+    end
+
+    def user
+      ActiveAudit.session[:current_user]
+    end
+
+    def user=(value)
+      ActiveAudit.session[:current_user] = value
+    end
+
+  end
+
+  ActiveSupport.on_load(:action_controller) do
+    if defined?(ActionController::Base)
+      ActionController::Base.around_action ActiveAudit::Sweeper.instance
+    end
+    if defined?(ActionController::API)
+      ActionController::API.around_action ActiveAudit::Sweeper.instance
+    end
+  end
+end

data/lib/generators/active_audit/install_generator.rb

@@ -0,0 +1,34 @@
+require 'rails/generators'
+require 'rails/generators/active_record'
+
+module ActiveAudit
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include ActiveRecord::Generators::Migration
+
+      desc "Create initializer and config files for active audit base on the adapter you define. In case of 'active_record' adapter a migration will be generated as well."
+
+      argument :adapter, required: true, type: :string, desc: "The name of the storage adapter you want to use.",
+           :banner => "adapter_name"
+
+      source_root File.expand_path("../templates", __FILE__)
+
+      def copy_initializer_file
+        template "initializer.rb", "config/initializers/active_audit.rb"
+      end
+
+      def copy_config_file
+        unless adapter == 'active_record'
+          copy_file "#{adapter}_config.yml", "config/active_audit.yml"
+        end
+      end
+
+      def generate_migration
+        if adapter == 'active_record'
+          migration_template 'migration.rb', 'db/migrate/create_audits.rb'
+        end
+      end
+
+    end
+  end
+end

data/lib/generators/active_audit/templates/adapter_config/elastic_search_config.yml

@@ -0,0 +1,12 @@
+development:
+  host: 'http://localhost:9200'
+  index: auditing
+test:
+  url: 'http://localhost:9200'
+  index: auditing
+staging:
+  url: 'http://localhost:9200'
+  index: auditing
+production:
+  url: <%= ENV["AUDIT_STORE_HOST"] %>
+  index: <%= ENV["AUDIT_STORE_INDEX"] %>

data/lib/generators/active_audit/templates/adapter_config/mongo_config.yml

@@ -0,0 +1,10 @@
+development:
+  hosts:
+    - localhost:27017
+  options:
+    database: audits
+production:
+  hosts:
+    - <%= ENV["AUDITING_MONGO_HOST"].split(',').join '\n\t\t- ' %>
+  options:
+    database: <%= ENV["AUDITING_MONGO_DATABASE_NAME"] %>

data/lib/generators/active_audit/templates/initializer.rb

@@ -0,0 +1,9 @@
+ActiveAudit.configure do |config|
+  config.storage_adapter = :<%= adapter.to_sym %>
+  #config.current_user_method = :current_user
+  #config.ignored_attributes = %w(created_at updated_at)
+  #config.job_queue = :audits
+  #config.delayed_auditing = false
+  #config.default_user = { id: 1 }
+  #config.extract_user_profile = lambda { |user| { id: user.id } }
+end

data/lib/generators/active_audit/templates/migration.rb

@@ -0,0 +1,22 @@
+class <%= migration_class_name %> < ActiveRecord::Migration
+  def self.up
+    create_table :audits, :force => true do |t|
+      t.column :item_id, :integer
+      t.column :type, :string
+      t.column :event, :string
+      t.column :changes, :json
+      t.column :user_id, :integer
+      t.column :user, :json
+      t.column :comment, :string
+      t.column :recorded_at, :datetime
+    end
+
+    add_index :audits, [:type, :item_id], :name => 'item_index'
+    add_index :audits, :user_id, :name => 'user_index'
+    add_index :audits, :recorded_at
+  end
+
+  def self.down
+    drop_table :audits
+  end
+end

data/lib/generators/active_audit/templates/mongo_config.yml

@@ -0,0 +1,10 @@
+development:
+  hosts:
+    - localhost:27017
+  options:
+    database: audits
+production:
+  hosts:
+    - <%= ENV["AUDITING_MONGO_HOST"].split(',').join '\n\t\t- ' %>
+  options:
+    database: <%= ENV["AUDITING_MONGO_DATABASE_NAME"] %>

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: active-audit
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Tariq Abughofa
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-07-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails-observers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+- !ruby/object:Gem::Dependency
+  name: virtus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: ORM extension to track model changes. It also support keeping record
+  of who made the changes and why.
+email: mhdtariqabughofa@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/active-audit.rb
+- lib/active_audit/audit.rb
+- lib/active_audit/audit_pusher.rb
+- lib/active_audit/audit_repository.rb
+- lib/active_audit/base.rb
+- lib/active_audit/dirty_association.rb
+- lib/active_audit/errors.rb
+- lib/active_audit/storage_adapters.rb
+- lib/active_audit/storage_adapters/active_record_adapter.rb
+- lib/active_audit/storage_adapters/elasticsearch_adapter.rb
+- lib/active_audit/storage_adapters/mongo_adapter.rb
+- lib/active_audit/storage_adapters/test_adapter.rb
+- lib/active_audit/sweeper.rb
+- lib/generators/active_audit/install_generator.rb
+- lib/generators/active_audit/templates/adapter_config/elastic_search_config.yml
+- lib/generators/active_audit/templates/adapter_config/mongo_config.yml
+- lib/generators/active_audit/templates/initializer.rb
+- lib/generators/active_audit/templates/migration.rb
+- lib/generators/active_audit/templates/mongo_config.yml
+homepage: http://rubygems.org/gems/active-audit
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: ORM extension to track model changes.
+test_files: []