loggable_activity 0.2.1 → 0.5.4

data/lib/loggable_activity/hooks.rb

@@ -24,6 +24,7 @@ module LoggableActivity
 
       # Initializes attributes based on configuration.
       self.loggable_attrs = config&.fetch('loggable_attrs', []) || []
+      self.public_attrs = config&.fetch('public_attrs', []) || []
       self.relations = config&.fetch('relations', []) || []
       self.auto_log = config&.fetch('auto_log', []) || []
       self.fetch_record_name_from = config&.fetch('fetch_record_name_from', nil)
@@ -60,6 +61,10 @@ module LoggableActivity
       end
     end
 
+    def disable_hooks!
+      self.disable_hooks = true
+    end
+
     private
 
     # Logs an activity for the current action.
@@ -134,6 +139,7 @@ module LoggableActivity
     # Logs a create activity automatically if configured.
     def log_create_activity
       return unless hooks_enabled?
+      return if id.nil?
 
       log(:create) if self.class.auto_log.include?('create')
     end
@@ -159,13 +165,13 @@ module LoggableActivity
 
     # Returns the encrypted name of the actor.
     def encrypted_actor_name
-      name = @actor.send(fetch_current_user_name_from)
+      name = @actor.send(fetch_actor_name_from)
       ::LoggableActivity::Encryption.encrypt(name, actor_secret_key)
     end
 
     # Reads the field to feetch the record name from.
-    def fetch_current_user_name_from
-      ::LoggableActivity::Configuration.fetch_current_user_name_from
+    def fetch_actor_name_from
+      ::LoggableActivity::Configuration.fetch_actor_name_from
     end
 
     # Returns the action key for the current action.
@@ -188,25 +194,14 @@ module LoggableActivity
       encryption_key_for_record(@actor)&.secret_key
     end
 
-    # Returns the display name of the actor.
-    def actor__name_field
-      Rails.application.config.loggable_activity.actor_display_name || "id: #{@actor.id}, class: #{@actor.class.name}"
-    end
-
-    # Returns the model name of the current user.
-    def current_user_model?
-      Rails.application.config.loggable_activity.current_user_model_name == self.class.name
-    end
-
     class_methods do
       # The loggable_attrs attribute is used read the configuration for the model that included LoggableActivity::Hooks.
-      attr_accessor :loggable_attrs, :relations, :auto_log, :fetch_record_name_from, :route
+      attr_accessor :loggable_attrs, :relations, :auto_log, :fetch_record_name_from, :route, :public_attrs
 
       # Convert the model name and name space in to 'base_action'.
       def base_action
         name.downcase.gsub('::', '/')
       end
-
     end
   end
 end

data/lib/loggable_activity/payload.rb

@@ -7,7 +7,6 @@ module LoggableActivity
   # When the record is deleted, the encryption key for the payload is also deleted.
   # Payloads come in different types, each serving a specific purpose.
   class Payload < ActiveRecord::Base
-    self.table_name = 'loggable_payloads'
     validates :related_to_activity_as, presence: true
 
     # Associations
@@ -63,14 +62,14 @@ module LoggableActivity
     #
     def attrs
       return deleted_attrs if record.nil?
-
+  
       case related_to_activity_as
       when *DECRYPT_ATTRS_TYPES
-        decrypted_attrs
+        decrypted_attrs.merge(public_attrs: public_attrs)
       when *DECRYPT_UPDATE_ATTRS_TYPES
-        decrypted_update_attrs
+        decrypted_update_attrs + public_attrs['changes']
       else
-        {}
+        { public_attrs: public_attrs }
       end
     end
 
@@ -93,7 +92,7 @@ module LoggableActivity
     #
     # @return [String] The display name for the record.
     def record_display_name
-      return I18n.t('loggable.activity.deleted') if deleted?
+      return I18n.t('loggable_activity.activity.deleted') if deleted?
 
       ::LoggableActivity::Encryption.decrypt(encrypted_record_name, secret_key)
     end
@@ -118,7 +117,7 @@ module LoggableActivity
     #
     # @return [Hash] The hash with deleted attributes.
     def deleted_attrs
-      encrypted_attrs.transform_values! { I18n.t('loggable.activity.deleted') }
+      encrypted_attrs.transform_keys(&:to_sym).transform_values! { I18n.t('loggable_activity.activity.deleted') }
     end
 
     # Decrypts the 'from' and 'to' attributes in the update payload.
@@ -139,7 +138,7 @@ module LoggableActivity
       change.to_h do |key, value|
         from = decrypt_attr(value['from'])
         to = decrypt_attr(value['to'])
-        [key, { from:, to: }]
+        [key.to_sym, { from:, to: }]
       end
     end
 
@@ -147,9 +146,7 @@ module LoggableActivity
     #
     # @return [Hash] The decrypted attributes.
     def decrypted_attrs
-      encrypted_attrs.each do |key, value|
-        encrypted_attrs[key] = decrypt_attr(value)
-      end
+      encrypted_attrs.transform_keys(&:to_sym).transform_values { |value| decrypt_attr(value) }
     end
 
     # Decrypts a single attribute.

data/lib/loggable_activity/sanitizer.rb

@@ -1,9 +1,13 @@
+# frozen_string_literal: true
+
 module LoggableActivity
+  # This module is responsible for sanitizing activities.
+  # When an encryption keys deleted_at field is set, the key is deleted.
   module Sanitizer
-    def self.run 
+    def self.run
       ::LoggableActivity::EncryptionKey.where('delete_at < ?', DateTime.now).find_in_batches do |batch|
         batch.each(&:delete)
       end
     end
   end
-end
+end

data/lib/loggable_activity/services/base_payloads_builder.rb

@@ -10,6 +10,7 @@ module LoggableActivity
         @record = record
         @payloads = payloads
         @loggable_attrs = record.class.loggable_attrs
+        @public_attrs = record.class.public_attrs
         # @relation_config = record.relation_config
         @relations = record.class.relations
         @auto_log = record.class.auto_log
@@ -67,19 +68,21 @@ module LoggableActivity
         return if encryption_key.deleted?
 
         secret_key = encryption_key.secret_key
-        encrypted_attrs = encrypt_attributes(record, secret_key)
+        encrypted_attrs = encrypt_attributes(record, secret_key, options)
+        public_attrs = public_attributes(record)
 
         build_payload(
           record,
           encryption_key,
           encrypted_attrs,
+          public_attrs,
           options
         )
         { encryption_key:, encrypted_attrs: }
       end
 
       # Builds the payload for a record
-      def build_payload(record, encryption_key, encrypted_attrs, options = {})
+      def build_payload(record, encryption_key, encrypted_attrs, public_attrs, options = {})
         return if encryption_key.deleted?
 
         related_to_activity_as = options[:related_to_activity_as]
@@ -96,7 +99,8 @@ module LoggableActivity
           related_to_activity_as:,
           route: record.class.route,
           current_payload:,
-          data_owner:
+          data_owner:,
+          public_attrs:
         )
         unless payload.valid?
           error_message = "Payload validation failed: #{payload.errors.full_messages.join(', ')}"
@@ -107,8 +111,9 @@ module LoggableActivity
       end
 
       # Encrypts the attributes for the record.
-      def encrypt_attributes(record, secret_key)
-        encrypt_attrs(record.attributes, record.class.loggable_attrs, secret_key)
+      def encrypt_attributes(record, secret_key, options = {})
+        loggable_attrs = options[:loggable_attrs] || record.class.loggable_attrs
+        encrypt_attrs(record.attributes, loggable_attrs, secret_key)
       end
 
       # Encrypt one attributes for only loggable_attrs, configured
@@ -118,6 +123,10 @@ module LoggableActivity
         end
       end
 
+      def public_attributes(record)
+        record.attributes.slice(*record.class.public_attrs)
+      end
+
       # Encrypt a single attribute.
       def encrypt_attr(value, secret_key)
         ::LoggableActivity::Encryption.encrypt(value, secret_key)

data/lib/loggable_activity/services/destroy_payloads_builder.rb

@@ -112,12 +112,13 @@ module LoggableActivity
         @payloads << ::LoggableActivity::Payload.new(
           encryption_key:,
           record_id: nil,
-          record_type: @record.class.name,
+          record_type: record.class.name,
           encrypted_record_name:,
           encrypted_attrs:,
           related_to_activity_as:,
           data_owner: true,
           route: '',
+          public_attrs: public_attributes(record),
           current_payload: true
         )
         encryption_key

data/lib/loggable_activity/services/payloads_builder.rb

@@ -57,10 +57,10 @@ module LoggableActivity
       def build_has_many_payloads(relation_config)
         relation = (relation_config['has_many']).to_s
         records = @record.send(relation)
-        data_owner = relation_config['data_owner']
+        data_owner = relation_config['data_owner'] || false
         options = { related_to_activity_as: 'has_many_payload', current_payload: true, data_owner: }
         records.each do |record|
-          record.disable_hooks = true
+          record.disable_hooks!
           build_encrypted_payload(record, options)
         end
       end
@@ -71,19 +71,26 @@ module LoggableActivity
         record = @record.send(relation)
         return if record.nil?
 
-        data_owner = relation_config['data_owner']
+        record.disable_hooks!
+
+        data_owner = relation_config['data_owner'] || false
         options =
-          { related_to_activity_as: 'has_one_payload', current_payload: true, data_owner: }
+          {
+            related_to_activity_as: 'has_one_payload',
+            current_payload: true, data_owner:,
+            loggable_attrs: relation_config['loggable_attrs']
+          }
 
         build_encrypted_payload(record, options)
       end
 
+      # Builds the payload for a belongs_to relation.
       def build_belongs_to_payload(relation_config)
         relation = (relation_config['belongs_to']).to_s
         record = @record.send(relation)
         return if record.nil?
 
-        data_owner = relation_config['data_owner']
+        data_owner = relation_config['data_owner'] || false
 
         if data_owner
           encryption_key = encryption_key_for_record(@record)

data/lib/loggable_activity/services/update_payloads_builder.rb

@@ -16,6 +16,7 @@ module LoggableActivity
       # Builds the primary payload.
       def build_primary_update_payload
         previous_values, current_values = saved_changes(@record)
+        public_attrs = updated_public_attrs(current_values.slice(*@public_attrs), previous_values.slice(*@public_attrs))
         previous_values = previous_values.slice(*@loggable_attrs)
         current_values = current_values.slice(*@loggable_attrs)
         options = { related_to_activity_as: 'primary_update_payload', current_payload: true, data_owner: true }
@@ -24,6 +25,7 @@ module LoggableActivity
           @record,
           current_values,
           previous_values,
+          public_attrs,
           options
         )
       end
@@ -54,7 +56,7 @@ module LoggableActivity
         relation_id = "#{relation_config['belongs_to']}_id"
         model_class_name = relation_config['model']
         model_class = model_class_name.constantize
-        data_owner = relation_config['data_owner']
+        data_owner = relation_config['data_owner'] || false
 
         model_ids = saved_changes(@record).map { |hash| hash[relation_id] }
 
@@ -92,21 +94,28 @@ module LoggableActivity
         loggable_attrs = relation_config['loggable_attrs']
         return if previous_values == current_values
 
+        public_attributes = relation_config['public_attrs']
+        public_attrs = updated_public_attrs(
+          current_values.slice(*public_attributes),
+          previous_values.slice(*public_attributes)
+        )
+
         previous_values = previous_values.slice(*loggable_attrs)
-        data_owner = relation_config['data_owner']
+        data_owner = relation_config['data_owner'] || false
         options = { related_to_activity_as: 'has_many_update_payload', current_payload: true, data_owner: }
 
         build_encrypted_update_payload(
           record,
           current_values,
           previous_values,
+          public_attrs,
           options
         )
       end
 
       def build_has_many_create_payload(relation_config, record)
         record.disable_hooks = true
-        data_owner = relation_config['data_owner']
+        data_owner = relation_config['data_owner'] || false
         options =
           { related_to_activity_as: 'has_many_create_payload', current_payload: true, data_owner: }
         build_encrypted_payload(record, options)
@@ -119,18 +128,24 @@ module LoggableActivity
         return nil if record.nil?
 
         previous_values, current_values = changes_to_save(record)
-        loggable_attrs = record.class.loggable_attrs
+        loggable_attrs = relation_config['loggable_attrs']
         return if previous_values == current_values
 
+        public_attrs = updated_public_attrs(
+          current_values.slice(*record.class.public_attrs),
+          previous_values.slice(*record.class.public_attrs)
+        )
+
         previous_values = previous_values.slice(*loggable_attrs)
         current_values = current_values.slice(*loggable_attrs)
-        data_owner = relation_config['data_owner']
+        data_owner = relation_config['data_owner'] || false
         options = { related_to_activity_as: 'has_one_update_payload', current_payload: true, data_owner: }
 
         build_encrypted_update_payload(
           record,
           current_values,
           previous_values,
+          public_attrs,
           options
         )
       end
@@ -148,8 +163,20 @@ module LoggableActivity
         { changes: }
       end
 
+      def updated_public_attrs(current_values, previous_values)
+        changes = []
+
+        previous_values.each do |key, from_value|
+          from = from_value
+          to_value = current_values[key]
+          to = to_value
+          changes << { key => { from:, to: } }
+        end
+        { changes: }
+      end
+
       # Builds the encrypted update payload for a record.
-      def build_encrypted_update_payload(record, current_values, previous_values, options = {})
+      def build_encrypted_update_payload(record, current_values, previous_values, public_attrs, options = {})
         encryption_key = ::LoggableActivity::EncryptionKey.for_record(record)
 
         encrypted_attrs = encrypted_update_attrs(
@@ -162,6 +189,7 @@ module LoggableActivity
           record,
           encryption_key,
           encrypted_attrs,
+          public_attrs,
           options
         )
       end

data/lib/loggable_activity/version.rb

@@ -3,5 +3,5 @@
 # Version of the gem
 module LoggableActivity
   # Version
-  VERSION = '0.2.1'
+  VERSION = '0.5.4'
 end

data/lib/loggable_activity.rb

@@ -1,16 +1,53 @@
 # frozen_string_literal: true
 
-require_relative 'loggable_activity/version'
-require_relative 'loggable_activity/activity'
-require_relative 'loggable_activity/configuration'
-require_relative 'loggable_activity/encryption'
-require_relative 'loggable_activity/encryption_key'
-require_relative 'loggable_activity/data_owner'
-require_relative 'loggable_activity/hooks'
-require_relative 'loggable_activity/payload'
-require_relative 'loggable_activity/error'
-require_relative 'loggable_activity/sanitizer'
-require_relative 'loggable_activity/services/base_payloads_builder'
-require_relative 'loggable_activity/services/payloads_builder'
-require_relative 'loggable_activity/services/update_payloads_builder'
-require_relative 'loggable_activity/services/destroy_payloads_builder'
+require 'loggable_activity/version'
+require 'loggable_activity/engine'
+require 'loggable_activity/hooks'
+require 'loggable_activity/activity'
+require 'loggable_activity/configuration'
+require 'loggable_activity/encryption'
+require 'loggable_activity/encryption_key'
+require 'loggable_activity/data_owner'
+require 'loggable_activity/payload'
+require 'loggable_activity/error'
+require 'loggable_activity/sanitizer'
+require 'loggable_activity/services/base_payloads_builder'
+require 'loggable_activity/services/payloads_builder'
+require 'loggable_activity/services/update_payloads_builder'
+require 'loggable_activity/services/destroy_payloads_builder'
+require 'loggable_activity/concerns/current_user'
+require 'kaminari'
+
+# LoggableActivity
+#
+# The LoggableActivity module provides a comprehensive solution for tracking and logging
+# user activities within a Rails application. It offers a flexible and extensible framework
+# for capturing, encrypting, and storing activity data, ensuring that sensitive information
+# is handled securely.
+#
+# Features:
+# - Activity Logging: Captures user actions across the application, providing insights into user behavior.
+# - Encryption: Ensures that logged data is encrypted, safeguarding user privacy and data security.
+# - Configuration: Offers customizable options to tailor the logging mechanism to specific application needs.
+# - Extensibility: Designed to be extensible, allowing developers to add custom logging capabilities as needed.
+#
+# Components:
+# - Hooks: Mechanisms to hook into application events for logging.
+# - Activity: The core model representing logged activities.
+# - Configuration: Manages configuration settings for the logging mechanism.
+# - Encryption: Handles the encryption and decryption of logged data.
+# - DataOwner: Identifies the owner of the logged data.
+# - Payload: Structures the data to be logged.
+# - Error: Defines custom error types for the logging process.
+# - Sanitizer: Provides data sanitization utilities.
+# - Services: Contains services for building and managing payloads.
+# - Concerns: Includes concerns for integrating with application models and controllers.
+#
+# Usage:
+# To use LoggableActivity, include it in your Rails application and configure it according to your needs.
+#
+# This module is designed to be both powerful and easy to integrate, providing a solid foundation for activity logging.
+module LoggableActivity
+  mattr_accessor :actor_class
+  mattr_accessor :config_file_path
+end

data/lib/tasks/loggable_activity_tasks.rake

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# desc "Explaining what the task does"
+# task :loggable_activity do
+#   # Task goes here
+# end