frederick_operations_logger 1.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c8489f6536a285d6114451401fd94d9d4043faf6
+  data.tar.gz: 9ad30e94ba02ee33085ca246a200783735b85e73
+SHA512:
+  metadata.gz: 5565ba1daa79f65f25323d080a9ffcb9c0de12cc9483622d3516fa859b7e1fa3b6991a59982e4db2828fda42b8e0e23d6602910993dceb5b33b9808d5521446e
+  data.tar.gz: 132ca1e9a3ba35ef17ef6cd3a734718de1a7d689a9345088c074e460854b988994d5d3171fac627a08558f9bd72cc2df6f91efee58cb137bbd21bebd9a1d83a2

data/README.md

@@ -0,0 +1,45 @@
+# Frederick Operations Logger
+
+[ ![Codeship Status for BookerSoftwareInc/frederick_operations_logger](https://app.codeship.com/projects/8e3097e0-ca7d-0135-871a-72c36ec6d502/status?branch=master)](https://app.codeship.com/projects/261776)
+
+Provides a Rails / ActiveRecord helper to automatically log all CRUD operations to the appropriate Kafka
+`operations_log` topic for other services to be notified on resource changes.
+
+## Example Usage
+
+```ruby
+# Gemfile
+
+FRED_GITHUB_URL = 'https://8218b10ce7d4e20bd6d96d25bd3358ecafb286d8:x-oauth-basic@github.com/BookerSoftwareInc/'
+gem 'frederick_internal_api', git: "#{FRED_GITHUB_URL}frederick_internal_api_gem.git"
+gem 'frederick_operations_logger', git: "#{FRED_GITHUB_URL}frederick_operations_logger.git"
+```
+
+```ruby
+class FooModel < ActiveRecord::Base
+  include FrederickOperationsLogger::ActiveRecord::Helper
+
+  # Adds an after_commit callback to log CRUD operations.
+  # Both a JSONAPI Resource class and Frederick API client class must be provided
+  # to be used by the logger when serializing the resource
+  # API Client classes are provided by the frederick_api gem or frederick_internal_api gem
+  # You can provide a string (as below) to reference a class if needed to avoid
+  # dependecy / load order issues between model and resource classes
+  logs_operations_with resource_class: 'Api::V2::FooResource', api_client_class: FrederickAPI::V2::Foo
+end
+```
+
+## RSpec Test Helper - add this to your model spec
+
+```ruby
+# spec/models/foo_model_spec.rb
+require 'spec_helper'
+require 'frederick_operations_logger/test/shared_examples'
+
+describe FooModel do
+  include_examples 'logs_operations_with', {
+    resource_class: Api::V2::FooResource,
+    api_client_class: FrederickAPI::V2::Foo
+  }
+end
+```

data/lib/frederick_operations_logger.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'frederick_internal_api'
+require 'frederick_operations_logger/active_record/helper'
+require 'request_store'
+
+# Base gem module
+module FrederickOperationsLogger
+  REQUEST_STORE_KEY = 'frederick_operations_logger_context'
+  ALLOWED_ACTIVITIES = [
+    're_accept_tos',                      # when subscribers re-accept TOS from ui dialog
+    'update_communication_preferences',   # when consumers update preferences from a ui
+  ].freeze
+  AUTH_INFO_KEYS = %i[user_id application_id application_name ip_address].freeze
+
+  # FrederickOperationsLogger.context = { activity: 'foo', auth_info: { user_id: 'some...uuid' } }
+  # using applications can set local context without concern for empty context in consumed message
+  # TODO: auth_info should be set automatically from frederick_api_auth_gem for REST calls
+  # auth_info: {
+  #   user_id: The user id performing the action (if not performed by a system function),
+  #   application_id: The Doorkeeper application ID that relates to the access token being used,
+  #   application_name: The Doorkeeper application name or internal application name performing the action
+  #   ip_address: The IP address of the authorized entity performing the action (user or application)
+  # }
+  # Use merge: false to replace an already set context instead of merging new info
+  def self.context=(activity: nil, auth_info: nil, extras: nil, merge: true)
+    auth_info = auth_info.compact.symbolize_keys if auth_info.present?
+    extras = extras.compact.deep_symbolize_keys if extras.present?
+
+    return if activity.nil? && auth_info.blank? && extras.blank? # safeguard against setting empty context
+    validate_context(activity, auth_info)
+
+    RequestStore.store[REQUEST_STORE_KEY] ||= {}
+    RequestStore.store[REQUEST_STORE_KEY][:context] = if merge
+                                                        merge_context(
+                                                          activity: activity,
+                                                          auth_info: auth_info,
+                                                          extras: extras
+                                                        )
+                                                      else
+                                                        {
+                                                          activity: activity,
+                                                          auth_info: auth_info,
+                                                          extras: extras
+                                                        }.compact
+                                                      end
+  end
+
+  def self.merge_context(activity: nil, auth_info: nil, extras: nil)
+    previous = self.context
+    new_auth_info = if auth_info.present?
+                      previous[:auth_info].present? ? previous[:auth_info].merge(auth_info) : auth_info
+                    else
+                      previous[:auth_info]
+                    end
+    new_extras = if extras.present?
+                   previous[:extras].present? ? previous[:extras].merge(extras) : extras
+                 else
+                   previous[:extras]
+                 end
+
+    {
+      activity: activity || previous[:activity],
+      auth_info: new_auth_info,
+      extras: new_extras
+    }.compact
+  end
+
+  # FrederickOperationsLogger.context
+  def self.context
+    RequestStore.store.dig(REQUEST_STORE_KEY, :context) || {}
+  end
+
+  def self.validate_context(activity, auth_info)
+    raise "Invalid activity: #{activity}" unless activity.nil? || ALLOWED_ACTIVITIES.include?(activity)
+    return unless auth_info.present? && (auth_info.keys - AUTH_INFO_KEYS).any?
+
+    raise "Invalid auth_info: only #{AUTH_INFO_KEYS.join(', ')} are allowed"
+  end
+end

data/lib/frederick_operations_logger/active_record/helper.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module FrederickOperationsLogger
+  module ActiveRecord
+    # Include this mixin and use `logs_operations_for` to add an
+    # `after_commit` callback that will log any database activity on this model to Kafka.
+    # The topic used is `{resource_name}_operations_log`.
+    module Helper
+      extend ActiveSupport::Concern
+
+      class_methods do
+        # Helper to set up resource operations logging
+        # @param resource_class string or class (string allowed to circumvent loading order issues)
+        def logs_operations_with(resource_class:, api_client_class:)
+          @resource_class = resource_class
+          @api_client_class = api_client_class
+          after_commit :log_to_operations_log
+        end
+
+        # Get the resource class set in .logs_operations_for
+        # Checks base_class as well to work in STI models (subclasses)
+        def resource_class
+          @resource_class ||= base_class.resource_class
+          @resource_class.is_a?(String) ? @resource_class = @resource_class.constantize : @resource_class
+        end
+
+        # Get the api client class set in .logs_operations_for
+        # Checks base_class as well to work in STI models (subclasses)
+        def api_client_class
+          @api_client_class ||= base_class.api_client_class
+          @api_client_class.is_a?(String) ? @api_client_class = @api_client_class.constantize : @api_client_class
+        end
+
+        # @return valid attributes for JSONAPI resource i.e. ['id', 'name']
+        def resource_attributes
+          return @resource_attributes if @resource_attributes
+
+          attrs = resource_class.instance_variable_get(:@_attributes)
+          raise "Resource: #{resource_class} has no attributes!" unless attrs.is_a?(Hash)
+
+          @resource_attributes = resource_class.instance_variable_get(:@_attributes).stringify_keys.keys
+        end
+
+        # Gets relationships from JSONAPI Resource
+        # @return hash keyed on relationship foreign key
+        # For example: { 'contact_type_id' => { name: 'contact_type', type: 'contact_types' } }
+        def resource_relationships
+          @resource_relationships ||= if resource_class.instance_variable_get(:@_relationships).nil?
+                                        {}
+                                      else
+                                        resource_class.instance_variable_get(:@_relationships)
+                                                      .each_with_object({}) do |(k, v), o|
+                                          o[v.foreign_key] = { name: k, type: v.type.to_s }
+                                        end.stringify_keys
+                                      end
+        end
+
+        # Additional options to write into kafka message along with json resource
+        def async_options
+          { context: FrederickOperationsLogger.context }
+        end
+      end
+
+      private def attributes_for_resource
+        attributes.slice(*included_attributes)
+      end
+
+      private def included_attributes
+        # Online log updated attributes and relationships on updates
+        return ((self.class.resource_attributes & previous_changes.keys) + %w[location_id id]) if log_action == :update
+        self.class.resource_attributes
+      end
+
+      private def add_relationships_for_log!(api_resource)
+        self.class.resource_relationships.each do |k, v|
+          if attributes[k].present?
+            api_resource.relationships.send(:"#{v[:name]}=", data: { type: v[:type], id: attributes[k] })
+          end
+        end
+      end
+
+      private def log_to_operations_log
+        additional_attr = {}
+        resource = self.class.api_client_class.new(attributes_for_resource)
+        add_relationships_for_log!(resource)
+
+        case log_action
+        when :destroy
+          return resource.async_log.destroy(self.class.async_options)
+        when :update
+          additional_attr = add_previous_changes
+          resource.mark_as_persisted!
+        end
+
+        resource.async_log.save(self.class.async_options.merge(additional_attr))
+      end
+
+      # resource: { previous_attributes: { location_group_id: 'foo' } }
+      private def add_previous_changes
+        previous_changes.each_with_object({}) do |(k, v), h|
+          h[k.to_sym] = v.first
+        end
+      end
+
+      private def log_action
+        if previous_changes.key?('id')
+          :create
+        elsif destroyed?
+          :destroy
+        else
+          :update
+        end
+      end
+    end
+  end
+end

data/lib/frederick_operations_logger/test/shared_examples.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples 'logs_operations_with' do |meta|
+  resource_class = meta[:resource_class]
+  api_client_class = meta[:api_client_class]
+
+  describe 'logs_operations_with' do
+    let(:instance) { subject }
+
+    before do
+      allow(instance).to receive(:log_to_operations_log)
+    end
+
+    it 'after_commit' do
+      instance.run_callbacks(:commit)
+      expect(instance).to have_received(:log_to_operations_log)
+    end
+
+    context 'resource_class' do
+      it resource_class.to_s do
+        expect(described_class.resource_class).to be resource_class
+      end
+    end
+
+    context 'api_client_class' do
+      it api_client_class.to_s do
+        expect(described_class.api_client_class).to be api_client_class
+      end
+    end
+  end
+end

data/lib/frederick_operations_logger/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module FrederickOperationsLogger
+  # Current gem version
+  VERSION = '1.1.2'
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: frederick_operations_logger
+version: !ruby/object:Gem::Version
+  version: 1.1.2
+platform: ruby
+authors:
+- Frederick Engineering
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-08-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: jsonapi-resources
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: request_store
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+description: Provides Rails helper for ActiveRecord Models to log operations for JSON
+  API Resources
+email:
+- tech@hirefrederick.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/frederick_operations_logger.rb
+- lib/frederick_operations_logger/active_record/helper.rb
+- lib/frederick_operations_logger/test/shared_examples.rb
+- lib/frederick_operations_logger/version.rb
+homepage: https://github.com/BookerSoftwareInc/frederick_operations_logger
+licenses: []
+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.6.14
+signing_key: 
+specification_version: 4
+summary: Frederick Internal Operations Logger
+test_files: []