ruby - Sistema de auditoría Rails con ActiveResource y ActiveRecord

ruby-on-rails-3 logging

Question

Tengo un gran proyecto con los modelos ActiveRecord y ActiveResource. Necesito implementar el registro de la actividad del usuario con estos modelos y también registrar los cambios de los atributos del modelo (guardar el estado del objeto o algo así). Los cambios pueden ser realizados por usuarios o por tareas cron rake.

También debo tener la posibilidad de buscar cualquier dato por fecha, cualquier campo ... etc.

Será bueno también generar mensajes legibles con la última actividad, por ejemplo

• El usuario Bob cambia su contraseña a * y envía un correo electrónico a ** en 2011-08-12 08:12
• Staff Jeff agregó nuevo socio: Nombre de la empresa en 2011-08-12 08:13
• Admin Jack ha eliminado el producto: Nombre del producto en 2011-09-12 11:11
• Cliente Sam ordenó un nuevo servicio: Nombre del servicio en 2011-09-12 11:12

¿Alguien implementa tal registro? Ideas? Consejos?

¿Debería usar gemas o puedo hacer toda la lógica con observadores que no cambian de modelo?

Me gustó gema https://github.com/airblade/paper_trail ¿alguien puede decir cómo puedo hacer que funcione con activeresource?

Answer 1

La gema acts_as_audited debería funcionar bien para ti:
https://github.com/collectiveidea/acts_as_audited

Y en lo que se refiere a ActiveResource, también será un modelo en alguna otra aplicación. Puede usar la gema en el lado del servidor, y no necesita auditarla en el lado del cliente. Todas las operaciones CRUD que usan ActiveResource finalmente se traducirían a operaciones CRUD en ActiveRecord (en el lado del servidor).

Por lo tanto, probablemente tenga que mirarlo desde la distancia, y la misma solución se aplicaría en ambos casos, pero en diferentes lugares.

Answer 2

https://github.com/collectiveidea/acts_as_audited

y

https://github.com/airblade/paper_trail

son ambas excelentes soluciones para ActiveRecord solamente, pero dado que gran parte de ActiveRecord se ha extraído a ActiveModel , es probable que sea razonable ampliarlo para que también sea compatible con ActiveResource , al menos para soporte de solo lectura. Miré a través de los gráficos de la red de Github y busqué en Google y no parece haber ningún desarrollo en curso de dicha solución, sin embargo, espero que sea más fácil de implementar sobre uno de estos dos complementos que comenzar desde cero. paper_trail parece estar en un desarrollo más activo y tiene algunos compromisos para Rails 3.1, por lo que puede estar más actualizado con los componentes internos de Rails y más fácil de extender, pero eso es solo un instinto: no estoy familiarizado con los aspectos internos de ninguno de los dos.

Answer 3

Echa un vistazo a esta transmisión de rieles, tal vez te pueda ayudar: Notificaciones

Answer 4

Estás buscando

https://github.com/collectiveidea/acts_as_audited

Pocos proyectos de código abierto usan ese complemento, creo que Red Mine y The Foreman .

Editar : lamentablemente solo puede hacer ActiveRecord, no ActiveResource.

Answer 5

Fivell, acabo de ver esta pregunta y no tengo tiempo para arreglar alteraciones esta noche antes de que caduque la recompensa, así que le daré mi código de auditoría que funciona con ActiveRecord y debería funcionar con ActiveResource, quizás con algunos ajustes (I no use ARes con la frecuencia suficiente como para saberlo). Sé que las devoluciones de llamada que usamos están ahí, pero no estoy seguro si ARes tiene el seguimiento de changes atributos sucios de ActiveRecord.

Este código registra cada CREATE / UPDATE / DELETE en todos los modelos (excepto CREATE en el modelo de registro de auditoría y cualquier otra excepción que especifique) con los cambios almacenados como JSON. También se almacena una traza inversa limpia para que pueda determinar qué código hizo el cambio (esto captura cualquier punto en su MVC, así como las tareas de rake y el uso de la consola).

Este código funciona para el uso de la consola, las tareas de rake y las solicitudes http, aunque generalmente solo el último registra al usuario actual. (Si mal no recuerdo, el observador ActiveRecord que este reemplazó no funcionó en las tareas de rake o la consola.) Oh, este código proviene de una aplicación Rails 2.3. Tengo un par de aplicaciones de Rails 3, pero no he necesitado este tipo. de auditar para ellos todavía.

No tengo un código que cree una buena visualización de esta información (solo profundizamos en los datos cuando tenemos que analizar un problema), pero dado que los cambios se almacenan como JSON, debería ser bastante sencillo.

Primero, almacenamos el usuario actual en User.current para que esté accesible en todas partes, por lo que en app/models/user.rb :

Class User < ActiveRecord::Base
cattr_accessor :current
...
end

El usuario actual se configura en el controlador de la aplicación para cada solicitud de ese modo (y no causa problemas de concurrencia):

def current_user
User.current = session[:user_id] ? User.find_by_id(session[:user_id]) : nil
end

Puede establecer User.current en sus tareas de rake si tiene sentido hacerlo.

A continuación, definimos el modelo para almacenar la app/models/audit_log_entry.rb información de auditoría app/models/audit_log_entry.rb - usted querrá personalizar IgnoreClassesRegEx para que se ajuste a cualquier modelo que no desee auditar:

# == Schema Information
#
# Table name: audit_log_entries
#
# id :integer not null, primary key
# class_name :string(255)
# entity_id :integer
# user_id :integer
# action :string(255)
# data :text
# call_chain :text
# created_at :datetime
# updated_at :datetime
#
class AuditLogEntry < ActiveRecord::Base
IgnoreClassesRegEx = /^ActiveRecord::Acts::Versioned|ActiveRecord.*::Session|Session|Sequence|SchemaMigration|CronRun|CronRunMessage|FontMetric$/
belongs_to :user
def entity (reload = false)
@entity = nil if reload
begin
@entity ||= Kernel.const_get(class_name).find_by_id(entity_id)
rescue
nil
end
end
def call_chain
return if call_chain_before_type_cast.blank?
if call_chain_before_type_cast.instance_of?(Array)
call_chain_before_type_cast
else
JSON.parse(call_chain_before_type_cast)
end
end
def data
return if data_before_type_cast.blank?
if data_before_type_cast.instance_of?(Hash)
data_before_type_cast
else
JSON.parse(data_before_type_cast)
end
end
def self.debug_entity(class_name, entity_id)
require ''fastercsv''
FasterCSV.generate do |csv|
csv << %w[class_name entity_id date action first_name last_name data]
find_all_by_class_name_and_entity_id(class_name, entity_id,
:order => ''created_at'').each do |a|
csv << [a.class_name, a.entity_id, a.created_at, a.action,
(a.user && a.user.first_name), (a.user && a.user.last_name), a.data]
end
end
end
end

A continuación, agregamos algunos métodos a ActiveRecord::Base para que funcionen las auditorías. Deberá consultar el método audit_log_clean_backtrace y modificarlo según sus necesidades. (FWIW, agregamos adiciones a las clases existentes en lib/extensions/*.rb que se cargan en un inicializador). En lib/extensions/active_record.rb :

class ActiveRecord::Base
cattr_accessor :audit_log_backtrace_cleaner
after_create :audit_log_on_create
before_update :save_audit_log_update_diff
after_update :audit_log_on_update
after_destroy :audit_log_on_destroy
def audit_log_on_create
return if self.class.name =~ /AuditLogEntry/
return if self.class.name =~ AuditLogEntry::IgnoreClassesRegEx
audit_log_create ''CREATE'', self, caller
end
def save_audit_log_update_diff
@audit_log_update_diff = changes.reject{ |k,v| ''updated_at'' == k }
end
def audit_log_on_update
return if self.class.name =~ AuditLogEntry::IgnoreClassesRegEx
return if @audit_log_update_diff.empty?
audit_log_create ''UPDATE'', @audit_log_update_diff, caller
end
def audit_log_on_destroy
return if self.class.name =~ AuditLogEntry::IgnoreClassesRegEx
audit_log_create ''DESTROY'', self, caller
end
def audit_log_create (action, data, call_chain)
AuditLogEntry.create :user => User.current,
:action => action,
:class_name => self.class.name,
:entity_id => id,
:data => data.to_json,
:call_chain => audit_log_clean_backtrace(call_chain).to_json
end
def audit_log_clean_backtrace (backtrace)
if !ActiveRecord::Base.audit_log_backtrace_cleaner
ActiveRecord::Base.audit_log_backtrace_cleaner = ActiveSupport::BacktraceCleaner.new
ActiveRecord::Base.audit_log_backtrace_cleaner.add_silencer { |line| line =~ ///lib//rake/.rb/ }
ActiveRecord::Base.audit_log_backtrace_cleaner.add_silencer { |line| line =~ ///bin//rake/ }
ActiveRecord::Base.audit_log_backtrace_cleaner.add_silencer { |line| line =~ ///lib//(action_controller|active_(support|record)|hoptoad_notifier|phusion_passenger|rack|ruby|sass)/// }
ActiveRecord::Base.audit_log_backtrace_cleaner.add_filter { |line| line.gsub(RAILS_ROOT, '''') }
end
ActiveRecord::Base.audit_log_backtrace_cleaner.clean backtrace
end
end

Finalmente, aquí están las pruebas que tenemos sobre esto: por supuesto, deberá modificar las acciones de prueba reales. test/integration/audit_log_test.rb

require File.dirname(__FILE__) + ''/../test_helper''
class AuditLogTest < ActionController::IntegrationTest
def setup
end
def test_audit_log
u = users(:manager)
log_in u
a = Alert.first :order => ''id DESC''
visit ''alerts/new''
fill_in ''alert_note''
click_button ''Send Alert''
a = Alert.first :order => ''id DESC'', :conditions => [''id > ?'', a ? a.id : 0]
ale = AuditLogEntry.first :conditions => {:class_name => ''Alert'', :entity_id => a.id }
assert_equal ''Alert'', ale.class_name
assert_equal ''CREATE'', ale.action
end
private
def log_in (user, password = ''test'', initial_url = home_path)
visit initial_url
assert_contain ''I forgot my password''
fill_in ''email'', :with => user.email
fill_in ''password'', :with => password
click_button ''Log In''
end
def log_out
visit logout_path
assert_contain ''I forgot my password''
end
end

Y test/unit/audit_log_entry_test.rb :

# == Schema Information
#
# Table name: audit_log_entries
#
# id :integer not null, primary key
# class_name :string(255)
# action :string(255)
# data :text
# user_id :integer
# created_at :datetime
# updated_at :datetime
# entity_id :integer
# call_chain :text
#
require File.dirname(__FILE__) + ''/../test_helper''
class AuditLogEntryTest < ActiveSupport::TestCase
test ''should handle create update and delete'' do
record = Alert.new :note => ''Test Alert''
assert_difference ''Alert.count'' do
assert_difference ''AuditLogEntry.count'' do
record.save
ale = AuditLogEntry.first :order => ''created_at DESC''
assert ale
assert_equal ''CREATE'', ale.action, ''AuditLogEntry.action should be CREATE''
assert_equal record.class.name, ale.class_name, ''AuditLogEntry.class_name should match record.class.name''
assert_equal record.id, ale.entity_id, ''AuditLogEntry.entity_id should match record.id''
end
end
assert_difference ''AuditLogEntry.count'' do
record.update_attribute ''note'', ''Test Update''
ale = AuditLogEntry.first :order => ''created_at DESC''
expected_data = {''note'' => [''Test Alert'', ''Test Update'']}
assert ale
assert_equal ''UPDATE'', ale.action, ''AuditLogEntry.action should be UPDATE''
assert_equal expected_data, ale.data
assert_equal record.class.name, ale.class_name, ''AuditLogEntry.class_name should match record.class.name''
assert_equal record.id, ale.entity_id, ''AuditLogEntry.entity_id should match record.id''
end
assert_difference ''AuditLogEntry.count'' do
record.destroy
ale = AuditLogEntry.first :order => ''created_at DESC''
assert ale
assert_equal ''DESTROY'', ale.action, ''AuditLogEntry.action should be CREATE''
assert_equal record.class.name, ale.class_name, ''AuditLogEntry.class_name should match record.class.name''
assert_equal record.id, ale.entity_id, ''AuditLogEntry.entity_id should match record.id''
assert_nil Alert.find_by_id(record.id), ''Alert should be deleted''
end
end
test ''should not log AuditLogEntry create entry and block on update and delete'' do
record = Alert.new :note => ''Test Alert''
assert_difference ''Alert.count'' do
assert_difference ''AuditLogEntry.count'' do
record.save
end
end
ale = AuditLogEntry.first :order => ''created_at DESC''
assert_equal ''CREATE'', ale.action, ''AuditLogEntry.action should be CREATE''
assert_equal record.class.name, ale.class_name, ''AuditLogEntry.class_name should match record.class.name''
assert_equal record.id, ale.entity_id, ''AuditLogEntry.entity_id should match record.id''
assert_nil AuditLogEntry.first(:conditions => { :class_name => ''AuditLogEntry'', :entity_id => ale.id })
if ale.user_id.nil?
u = User.first
else
u = User.first :conditions => [''id != ?'', ale.user_id]
end
ale.user_id = u.id
assert !ale.save
assert !ale.destroy
end
end

Answer 6

para rastrear la actividad del usuario (CRUD), he creado una clase que hereda de Logger, y ahora estoy planeando escribir un pequeño complemento para rastrear usuarios que pueda usar para cualquier aplicación ROR creada. Ya he comprobado si hay un complemento así, pero no lo vi. Supongo que hay muchas gemas como paper-trail, acts_as_audited o itslog, pero prefiero usar un plugin. ¿Alguna sugerencia? Aquí hay un enlace que podría ayudarlo: http://robaldred.co.uk/2009/01/custom-log-log-files-for-your-ruby-on-rails-applications/comment-page-1/#comment- 342

buena codificación