zuora_connect 0 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b69457446868cd3b97d81d5753a967f002d58dfc750c2a4cae9b880a590c741
-  data.tar.gz: e27a81b4e9f30562ff67632d57c3b9e798e76677b5b4ee7c2698473a349bb111
+  metadata.gz: 0342c5ac7396b4e8ba75aff8dbab5d579fa6d0ad04a421b7d1d809ab3abbd90a
+  data.tar.gz: 70f7277a93fec8e481f63e56f85e466b5e0b4d1307e2413e4f8da9497e980be2
 SHA512:
-  metadata.gz: cb57173d9c5ef615f65d42a1fb6034f47c9878840063d3d243b774ed036e3b30f82a86943b1cfccf9a6534d69849a47468a51b1978e6720a012320025120e9ae
-  data.tar.gz: 53cad727a3c349daf72ee6f3b77c6dfebfe658f41470feb2bc259c4cd5dda994f28f00291d8fa6b14e2feda38df2acc033fef79d8875c5a8c0e6acbef083581b
+  metadata.gz: eb6497a343dde2b4a3edfe470c8e5a44eb37ff99b75ed434138c280e8ac25bf36806d58fbb477772182596917f1c37c0e237bd55e88f646e149743477fba2f15
+  data.tar.gz: f0b1f8b6f647f204ce8c4bfed7a8e77b49f3aada0faf6a0c31fc47675f5bfca67feb464692006bcb490977a577d1d5a3feab53886815f4c6472023e9ade6823b

data/app/assets/javascripts/hallway_wrapper/after.js

@@ -4,12 +4,31 @@ window.define = previousDefine;
 if (isHallway()) {
   $( document ).ajaxError(function( event, jqxhr, settings, thrownError ) {
     if ( jqxhr.status === 401) {
-      window.location.href = '/apps/newlogin.do?retURL=' + window.location.pathname;
+      fetch("https://" + window.location.host + "/apps/v1/navigation").then(response => {
+        if (response.status === 401) {
+          deleteAllCookies();
+          window.location.href = '/apps/newlogin.do?retURL=' + window.location.pathname;
+        }
+      });
     }
   });
 }
 
 function isHallway() {
-  var regex = new RegExp("^/services/");
-  return window.location.pathname.match(regex);
+  var regex = new RegExp("(?<=\\/)services\\/.*");
+  if (regex.test(window.location.pathname)) {
+    return window.location.pathname.match(regex)[0]
+  }
+  return null;
+}
+
+function deleteAllCookies() {
+  var cookies = document.cookie.split(";");
+
+  for (var i = 0; i < cookies.length; i++) {
+    var cookie = cookies[i];
+    var eqPos = cookie.indexOf("=");
+    var name = eqPos > -1 ? cookie.substr(0, eqPos) : cookie;
+    document.cookie = name + "=;expires=Thu, 01 Jan 1970 00:00:00 GMT;path=/";
+  }
 }

data/app/controllers/zuora_connect/static_controller.rb

@@ -1,31 +1,30 @@
 module ZuoraConnect
   class StaticController < ApplicationController
-    before_action :authenticate_connect_app_request, :except => [:metrics, :health, :session_error, :invalid_app_instance_error, :initialize_app]
-    before_action :clear_connect_app_session,        :only =>   [:metrics, :health, :session_error, :invalid_app_instance_error, :initialize_app]
-    after_action :persist_connect_app_session,       :except => [:metrics, :health, :session_error, :invalid_app_instance_error, :initialize_app]
+    before_action :authenticate_connect_app_request, :except => [:metrics, :health, :initialize_app]
+    before_action :clear_connect_app_session,        :only =>   [:metrics, :health, :initialize_app]
+    after_action :persist_connect_app_session,       :except => [:metrics, :health, :initialize_app]
     
     skip_before_action :verify_authenticity_token, :only => [:initialize_app]
 
-    def session_error
-      respond_to do |format|
-        format.html
-        format.json { render json: { message: "Session Error", status: 500 }, status: 500 }
-      end
-    end
-
-    def invalid_app_instance_error
-      respond_to do |format|
-        format.html
-        format.json {render json: { message: "Invalid App Instance", status: 500 }, status: 500 }
-      end
-    end
-
     def metrics
       type = params[:type].present? ? params[:type] : "versions"
       render json: ZuoraConnect::AppInstance.get_metrics(type).to_json, status: 200
     end
 
     def health
+      if params[:error].present?
+        begin 
+          raise ZuoraConnect::Exceptions::Error.new('This is an error')
+        rescue => ex
+          case params[:error]
+          when 'Log'  
+            Rails.logger.error("Error in Health", ex)
+          when 'Exception'
+            raise
+          end
+        end
+      end
+
       render json: {
         message: "Alive",
         status: 200
@@ -35,15 +34,21 @@ module ZuoraConnect
     def initialize_app
       begin
         authenticate_connect_app_request
+        @appinstance.new_session(:session => @appinstance.data_lookup(:session => session))
         render json: {
           message: "Success",
           status: 200
         }, status: 200
-      rescue
-        render json: {
-          message: "Failure initializing app instance",
-          status: 500
-        }, status: 500
+      rescue => ex
+        Rails.logger.error("Failed to Initialize application", ex)
+        if performed?
+          Rails.logger.error("Failed to Initialize application #{performed?}", ex)
+        else
+          render json: {
+            message: "Failure initializing app instance",
+            status: 500
+          }, status: 500
+        end
       end
     end
 

data/app/helpers/zuora_connect/application_helper.rb

@@ -1,5 +1,15 @@
 module ZuoraConnect
   module ApplicationHelper
+    def is_app_admin?
+      return @appinstance.blank? ? false : session["#{@appinstance.id}::admin"]
+    end
 
+    def zuora_user
+      return @zuora_user
+    end
+
+    def connect_meta_tags
+      "<meta name=\"z-hallway-prefix\" content=\"#{ Thread.current[:isHallway] }\">".html_safe
+    end
   end
 end

data/app/models/zuora_connect/app_instance_base.rb

@@ -1,9 +1,13 @@
 module ZuoraConnect
   require "uri"
+  require 'aws-sigv4'
+  require 'aws-sdk-s3'
+  require 'aws-sdk-ses'
+  require 'aws-sdk-kms'
   class AppInstanceBase < ActiveRecord::Base
     default_scope {select(ZuoraConnect::AppInstance.column_names.delete_if {|x| ["catalog_mapping", "catalog"].include?(x) }) }
     after_initialize :init
-    after_create :initialize_redis_placeholder
+    after_create :initialize_redis_placeholders
     before_destroy :prune_data
 
     self.table_name = "zuora_connect_app_instances"
@@ -15,7 +19,19 @@ module ZuoraConnect
     API_LIMIT_TIMEOUT = 2.minutes             #Used to set the default for expiring timeout when api rate limiting is in effect
     BLANK_OBJECT_ID_LOOKUP = 'BlankValueSupplied'
     HOLDING_PATTERN_SLEEP = 5.seconds
-    CONNECT_COMMUNICATION_SLEEP= 5.seconds
+    CONNECT_APPLICATION_ID = 0
+    CONNECT_COMMUNICATION_SLEEP = Rails.env.test? ? 0.seconds : 5.seconds
+    IGNORED_LOCALS = ['fr', 'ja', 'es', 'zh', 'de']
+    INTERNAL_HOSTS = []
+    LOGIN_TENANT_DESTINATION = 'target_login'
+    AWS_AUTH_ERRORS = [
+      Aws::Sigv4::Errors::MissingCredentialsError,
+      Aws::Errors::MissingCredentialsError,
+      Aws::S3::Errors::AccessDenied,
+      Aws::SES::Errors::AccessDenied,
+      Aws::KMS::Errors::AccessDeniedException 
+    ].freeze
+    AWS_AUTH_ERRORS_MSG = "AWS Auth Errors".freeze
 
     def init
       self.connect_user = 'Nobody'
@@ -27,46 +43,73 @@ module ZuoraConnect
       self.attr_builder("timezone", ZuoraConnect.configuration.default_time_zone)
       self.attr_builder("locale", ZuoraConnect.configuration.default_locale)
       PaperTrail.whodunnit = "Backend" if defined?(PaperTrail)
-      if defined?(ElasticAPM)
+      if defined?(ElasticAPM) && ElasticAPM.running?
         ElasticAPM.set_user("Backend")
-        ElasticAPM.set_tag(:app_instance, self.id) 
+        if ElasticAPM.respond_to?(:set_label)
+          ElasticAPM.set_label(:app_instance, self.id)
+        else
+          ElasticAPM.set_label(:app_instance, self.id)
+        end
       end
 
       if INSTANCE_REFRESH_WINDOW > INSTANCE_REDIS_CACHE_PERIOD
         raise "The instance refresh window cannot be greater than the instance cache period"
       end
       self.apartment_switch(nil, false)
+
+      if ZuoraConnect.logger.is_a?(Ougai::Logger)
+        ZuoraConnect.logger.with_fields.merge!(default_ougai_items)
+      end
+      if Rails.logger.is_a?(Ougai::Logger)
+        Rails.logger.with_fields.merge!(default_ougai_items)
+      end
     end
 
-    def initialize_redis_placeholder
+    def initialize_redis_placeholders
       if defined?(Redis.current)
-        Redis.current.zrem("AppInstance:Deleted", id)
-        Redis.current.zadd("APILimits", 9999999999, "placeholder")
-        Redis.current.zadd("InstanceRefreshing", 9999999999, "placeholder")
+        unless Redis.current.zscore("AppInstance:Deleted", "placeholder").present? # O(1)
+          Redis.current.zadd("AppInstance:Deleted", 9_999_999_999, "placeholder") # O(log(N))
+        end
+        if self.id.present?
+          if Redis.current.zscore("AppInstance:Deleted", self.id).present? # O(1)
+            Redis.current.zrem("AppInstance:Deleted", self.id) # O(log(N))
+          end
+        end
+        unless Redis.current.zscore("APILimits", "placeholder").present? # O(1)
+          Redis.current.zadd("APILimits", 9_999_999_999, "placeholder") # O(log(N))
+        end
+        unless Redis.current.zscore("InstanceRefreshing", "placeholder").present? # O(1)
+          Redis.current.zadd("InstanceRefreshing", 9_999_999_999, "placeholder") # O(log(N))
+        end
       end
       if defined?(Resque.redis)
-        Resque.redis.zadd("PauseQueue", 9999999999, "placeholder")
+        unless Resque.redis.zscore("PauseQueue", "placeholder").present? # O(1)
+          Resque.redis.zadd("PauseQueue", 9_999_999_999, "placeholder") # O(log(N))
+        end
       end
+      true
     end
 
-    def prune_data(id: self.id)
+    def prune_data
       if defined?(Redis.current)
-        Redis.current.zadd("AppInstance:Deleted", Time.now.to_i, id)
-        Redis.current.del("AppInstance:#{id}")
-        Redis.current.zrem("APILimits", id)
-        Redis.current.zrem("InstanceRefreshing", id)
+        Redis.current.zadd("AppInstance:Deleted", Time.now.to_i, self.id)
+        Redis.current.del("AppInstance:#{self.id}")
+        Redis.current.zrem("APILimits", self.id)
+        Redis.current.zrem("InstanceRefreshing", self.id)
       end
       if defined?(Resque.redis)
-        Resque.redis.zrem("PauseQueue", id)
+        Resque.redis.zrange("PauseQueue", 0, -1).each do |key|
+          Resque.redis.zrem("PauseQueue", key) if key.split("__").first.to_i == self.id
+        end
       end
       return true
-    end 
+    end
 
     def apartment_switch(method = nil, migrate = false)
       switch_count ||= 0
       if self.persisted?
         begin
-          Apartment::Tenant.switch!(self.id) 
+          Apartment::Tenant.switch!(self.id)
         rescue Apartment::TenantNotFound => ex
           sleep(2)
           begin
@@ -74,9 +117,9 @@ module ZuoraConnect
           rescue Apartment::TenantExists => ex
           end
           if (switch_count += 1) < 2
-            retry 
+            retry
           else
-            raise 
+            raise
           end
         end
         if migrate && ActiveRecord::Migrator.needs_migration?
@@ -86,19 +129,24 @@ module ZuoraConnect
       Thread.current[:appinstance] = self
     end
 
-    def new_session(session: self.data_lookup, username: self.access_token, password: self.refresh_token, holding_pattern: false, log_level: Logger::DEBUG)
+    def default_ougai_items
+      return {app_instance_id: self.id, tenant_ids: self.zuora_tenant_ids, organization: self.organizations, environment: self.environment}
+    end
+
+    def new_session(session: self.data_lookup, username: self.access_token, password: self.refresh_token, holding_pattern: false, **args)
       self.api_version = "v2"
       self.username = username
       self.password = password
       self.last_refresh = session["#{self.id}::last_refresh"]
       self.connect_user = session["#{self.id}::user::email"] if session["#{self.id}::user::email"].present?
       PaperTrail.whodunnit = self.connect_user if defined?(PaperTrail)
-      ElasticAPM.set_user(self.connect_user)   if defined?(ElasticAPM) 
+      ElasticAPM.set_user(self.connect_user)   if defined?(ElasticAPM) && ElasticAPM.running?
       recoverable_session = false
 
       ## DEV MODE TASK DATA MOCKUP
       if ZuoraConnect.configuration.mode != "Production"
         mock_task_data = {
+          "id" => ZuoraConnect.configuration.dev_mode_appinstance,
           "mode" => ZuoraConnect.configuration.dev_mode_mode
         }
 
@@ -115,31 +163,32 @@ module ZuoraConnect
         end
 
         self.build_task(task_data: mock_task_data, session: session)
+        self.last_refresh = Time.now.to_i
       else
         time_expire = (session["#{self.id}::last_refresh"] || Time.now).to_i - INSTANCE_REFRESH_WINDOW.ago.to_i
 
         if session.empty?
           self.new_session_message = "REFRESHING - Session Empty"
-          Rails.logger.add(log_level, self.new_session_message)
+          ZuoraConnect.logger.debug(self.new_session_message)
           raise ZuoraConnect::Exceptions::HoldingPattern if holding_pattern && !self.mark_for_refresh
           self.refresh(session: session)
 
         elsif (self.id != session["appInstance"].to_i)
           self.new_session_message = "REFRESHING - AppInstance ID(#{self.id}) does not match session id(#{session["appInstance"].to_i})"
-          Rails.logger.add(log_level, self.new_session_message)
+          ZuoraConnect.logger.debug(self.new_session_message)
           raise ZuoraConnect::Exceptions::HoldingPattern if holding_pattern && !self.mark_for_refresh
           self.refresh(session: session)
 
         elsif session["#{self.id}::task_data"].blank?
           self.new_session_message = "REFRESHING - Task Data Blank"
-          Rails.logger.add(log_level, self.new_session_message)
+          ZuoraConnect.logger.debug(self.new_session_message)
           raise ZuoraConnect::Exceptions::HoldingPattern if holding_pattern && !self.mark_for_refresh
           self.refresh(session: session)
 
         elsif session["#{self.id}::last_refresh"].blank?
           self.new_session_message = "REFRESHING - No Time on Cookie"
           recoverable_session = true
-          Rails.logger.add(log_level, self.new_session_message)
+          ZuoraConnect.logger.debug(self.new_session_message)
           raise ZuoraConnect::Exceptions::HoldingPattern if holding_pattern && !self.mark_for_refresh
           self.refresh(session: session)
 
@@ -147,7 +196,7 @@ module ZuoraConnect
         elsif (session["#{self.id}::last_refresh"].to_i < INSTANCE_REFRESH_WINDOW.ago.to_i) && self.mark_for_refresh
           self.new_session_message = "REFRESHING - Session Old by #{time_expire.abs} second"
           recoverable_session = true
-          Rails.logger.add(log_level, self.new_session_message)
+          ZuoraConnect.logger.debug(self.new_session_message)
           self.refresh(session: session)
 
         else
@@ -156,82 +205,194 @@ module ZuoraConnect
           else
             self.new_session_message = "REBUILDING - Expires in #{time_expire} seconds"
           end
-          Rails.logger.add(log_level, self.new_session_message)
+          ZuoraConnect.logger.debug(self.new_session_message, self.default_ougai_items)
           self.build_task(task_data: session["#{self.id}::task_data"], session: session)
         end
-      end      
+      end
       return self
     rescue ZuoraConnect::Exceptions::HoldingPattern => ex
       while self.marked_for_refresh?
-        Rails.logger.info("Holding - Expires in #{self.reset_mark_expires_at}. '#{self.new_session_message}'")
+        ZuoraConnect.logger.info("Holding - Expires in #{self.reset_mark_expires_at}. '#{self.new_session_message}'", self.default_ougai_items)
         sleep(HOLDING_PATTERN_SLEEP)
       end
       self.reload_attributes([:refresh_token, :oauth_expires_at, :access_token])
       session = self.data_lookup(session: session)
       retry
-    rescue => ex 
+    rescue ZuoraConnect::Exceptions::MissMatch => ex
+      self.delete_app_instance
+      session = {}
+      ZuoraConnect.logger.error(ex, self.default_ougai_items.merge({app_instance_id_new: self.task_data['id']}))
+      retry
+    rescue ZuoraConnect::Exceptions::InvalidCredentialSet => ex
+      raise
+    rescue => ex
       if recoverable_session
-        Rails.logger.error("REBUILDING - Using backup expired cache")
+        ZuoraConnect.logger.warn("REBUILDING - Using backup expired cache", ex, self.default_ougai_items)
         self.build_task(task_data: session["#{self.id}::task_data"], session: session)
         return self
       else
+        ZuoraConnect.logger.error("Failed new session", ex, self.default_ougai_items)
         raise
       end
     ensure
       begin
         I18n.locale = self.locale
       rescue I18n::InvalidLocale => ex
-        Rails.logger.debug("Invalid Locale: #{ex.message}")
+        ZuoraConnect.logger.error(ex) if !IGNORED_LOCALS.include?(ex.locale.to_s.downcase)
       end
       Time.zone = self.timezone
-      tenants = self.task_data.dig('tenant_ids') || []
-      organizations = self.task_data.dig('organizations') || []
-      if defined?(ElasticAPM) 
-        ElasticAPM.set_tag(:tenant_id, tenants.first) 
-        ElasticAPM.set_tag(:organization, organizations.first) 
-      end
-      self.logitem(item: {tenant_ids: tenants, organization: organizations})
-      self.update_column(:name, self.task_data.dig('name')) if ZuoraConnect::AppInstance.column_names.include?('name') && self.task_data.dig('name') != self.name 
+      if self.task_data.present?
+        tenants = self.task_data.fetch('tenant_ids', [])
+        organizations = self.task_data.fetch('organizations', [])
+        if defined?(ElasticAPM) && ElasticAPM.running?
+          if ElasticAPM.respond_to?(:set_label)
+            ElasticAPM.set_label(:tenant_id, tenants.first)
+            ElasticAPM.set_label(:organization, organizations.first)
+          else
+            ElasticAPM.set_label(:tenant_id, tenants.first)
+            ElasticAPM.set_label(:organization, organizations.first)
+          end
+        end
+
+        params = {
+          name: self.task_data.dig('name'), 
+          zuora_entity_ids: (self.task_data.dig(LOGIN_TENANT_DESTINATION,'entities') || []).map{|e| e['id']}.uniq,
+          zuora_tenant_ids: tenants.map(&:to_s).uniq,
+          organizations: organizations
+        }
+        if self.methods.include?(LOGIN_TENANT_DESTINATION.to_sym)
+          client = self.send(LOGIN_TENANT_DESTINATION).client
+          if defined?(client.rest_domain)
+            ZuoraConnect::RequestIdMiddleware.zuora_rest_domain = client.rest_domain
+            params.merge!({zuora_domain: client.rest_domain, environment: client.environment }) 
+          end
+        end
+        params = params.reject{|k,v| !self.attributes.keys.member?(k.to_s) || self[k] == v}
+        self.update_columns(params) if params.present?
+      end
     end
 
-    def refresh(session: {}, session_fallback: false)
+    def refresh(session: {}) 
       refresh_count ||= 0
-      start = Time.now
-      response = HTTParty.get(ZuoraConnect.configuration.url + "/api/#{self.api_version}/tools/tasks/#{self.id}.json",:body => {:access_token => self.access_token})
-      response_time = Time.now - start
+      skip_connect ||= false
+      begin
+        #Check how app was deployed
+        if self.id < 25000000 && !skip_connect 
+          self.check_oauth_state
+          response = HTTParty.get(ZuoraConnect.configuration.url + "/api/#{self.api_version}/tools/tasks/#{self.id}.json",:body => {:access_token => self.access_token})
+
+          if response.code == 200
+            begin
+              parsed_json = JSON.parse(response.body)
+            rescue JSON::ParserError => ex
+              raise ZuoraConnect::Exceptions::ConnectCommunicationError.new("JSON parse error", response.body, response.code)
+            end
 
-      Rails.logger.debug("[#{self.id}] REFRESH TASK - Connect Task Info Request Time #{response_time.round(2).to_s}")
-      if response.code == 200
-        self.build_task(task_data: JSON.parse(response.body), session: session)
+            self.build_task(task_data: parsed_json, session: session)  
+            if self.kms_key.present? && self.kms_key.match(/^arn:aws:.*/)
+              begin
+                self.zuora_logins = self.strip_cache_data(object: parsed_json.dup, keys: ['applications', 'tokens', 'user_settings'])
+                self.save(:validate => false)
+              rescue Aws::KMS::Errors::ValidationException, *AWS_AUTH_ERRORS => ex
+                Rails.logger.warn(AWS_AUTH_ERRORS_MSG, ex)
+              rescue => ex
+                Rails.logger.error(AWS_AUTH_ERRORS_MSG, ex)
+              end
+            end        
+          else
+            raise ZuoraConnect::Exceptions::ConnectCommunicationError.new("Error Communicating with Connect", response.body, response.code)
+          end
+        else
+          self.build_task(task_data: self.zuora_logins, session: session)
+        end
         self.last_refresh = Time.now.to_i
         self.cache_app_instance
         self.reset_mark_for_refresh
-      else
-        Rails.logger.fatal("[#{self.id}] REFRESH TASK - Failed Code #{response.code}")
-        raise ZuoraConnect::Exceptions::ConnectCommunicationError.new("Error Communicating with Connect", response.body, response.code)
+      rescue *(ZuoraAPI::Login::CONNECTION_EXCEPTIONS + ZuoraAPI::Login::CONNECTION_READ_EXCEPTIONS) => ex
+        refresh_count += 1
+        if refresh_count < 3
+          sleep(10)
+          ZuoraConnect.logger.debug("REFRESH TASK - Connection Failure Retrying(#{refresh_count})", ex, self.default_ougai_items)
+          retry
+        else
+          ZuoraConnect.logger.fatal("REFRESH TASK - Connection Failed", ex)
+          raise
+        end
+      rescue ZuoraConnect::Exceptions::ConnectCommunicationError => ex
+        refresh_count += 1
+        if refresh_count < 3
+          ZuoraConnect.logger.debug("REFRESH TASK - Communication Failure Retrying(#{refresh_count})", ex, self.default_ougai_items)
+          self.refresh_oauth if ex.code == 401
+          retry
+        else
+          ZuoraConnect.logger.fatal("REFRESH TASK - Communication Failed #{ex.code}", ex, self.default_ougai_items)
+          raise
+        end
       end
-    rescue *(ZuoraAPI::Login::CONNECTION_EXCEPTIONS).concat(ZuoraAPI::Login::CONNECTION_READ_EXCEPTIONS) => ex
-      if (refresh_count += 1) < 3
-        Rails.logger.info("[#{self.id}] REFRESH TASK - #{ex.class} Retrying(#{refresh_count})")
+    rescue => ex
+      if self['zuora_logins'].present?
+        ZuoraConnect.logger.warn("REFRESH TASK - Fallback to local encrypted store", ex, self.default_ougai_items)
+        skip_connect = true
         retry
-      else
-        Rails.logger.fatal("[#{self.id}] REFRESH TASK - #{ex.class} Failed #{refresh_count}x")
-        raise
       end
-    rescue ZuoraConnect::Exceptions::ConnectCommunicationError => ex
-      if (refresh_count += 1) < 3
-        Rails.logger.info("[#{self.id}] REFRESH TASK - Failed Retrying(#{refresh_count})")
-        if ex.code == 401
-          self.refresh_oauth
+      raise
+    end
+
+    #### START KMS ENCRYPTION Methods ####
+      def zuora_logins=(val)
+        write_attribute(:zuora_logins, kms_encrypt(val.to_json))
+      end
+
+      def zuora_logins
+        raise  ZuoraConnect::Exceptions::ConnectCommunicationError.new("Zuora Logins is blank, cannot decrypt.") if super.blank?
+        return JSON.parse(kms_decrypt(super))
+      end
+
+      def kms_decrypt(value)
+        kms_tries ||= 0
+        kms_client = Aws::KMS::Client.new({region: Rails.application.secrets.aws['AWS_REGION'], credentials: self.aws_auth_client}.delete_if { |k, v| v.blank? })
+        resp = kms_client.decrypt({ciphertext_blob: [value].pack("H*") })
+        return resp.plaintext
+      rescue *AWS_AUTH_ERRORS => ex
+        if (kms_tries += 1) < 3
+          Rails.logger.warn(AWS_AUTH_ERRORS_MSG, ex)
+          retry
+        else
+          Rails.logger.error(AWS_AUTH_ERRORS_MSG, ex)
+          raise
         end
-        retry
-      else
-        Rails.logger.fatal("[#{self.id}] REFRESH TASK - Failed #{refresh_count}x")
-        raise
       end
-    end
 
-    #### START Metrics Mathods ####
+      def kms_encrypt(value)
+        kms_tries ||= 0
+        kms_client = Aws::KMS::Client.new({region: Rails.application.secrets.aws['AWS_REGION'], credentials: self.aws_auth_client}.delete_if {|k,v| v.blank? })
+
+        resp = kms_client.encrypt({key_id: kms_key, plaintext: value})
+        return resp.ciphertext_blob.unpack('H*').first
+      rescue *AWS_AUTH_ERRORS => ex
+        if (kms_tries += 1) < 3
+          Rails.logger.warn(AWS_AUTH_ERRORS_MSG, ex)
+          retry
+        else
+          Rails.logger.error(AWS_AUTH_ERRORS_MSG, ex)
+          raise
+        end
+      end
+
+      def kms_key
+        return ENV['AWS_KMS_ARN'] || Rails.application.secrets.dig(:aws,'AWS_KMS_ARN')
+      end
+
+      def aws_auth_client
+        if Rails.env.to_s == 'development'
+          return Aws::Credentials.new(Rails.application.secrets.aws['AWS_ACCESS_KEY_ID'], Rails.application.secrets.aws['AWS_SECRET_ACCESS_KEY'])
+        else
+          return nil
+        end
+      end
+    #### END KMS ENCRYPTION Methods ####
+
+    #### START Metrics Methods ####
       def logitem(item: {}, reset: false)
         self.logitems = {} if self.logitems.class != Hash
         if item.class == Hash
@@ -243,10 +404,45 @@ module ZuoraConnect
       def self.write_to_telegraf(*args)
         if ZuoraConnect.configuration.enable_metrics
           @@telegraf_host = ZuoraConnect::Telegraf.new() if @@telegraf_host == nil
+          unicorn_stats = self.unicorn_listener_stats() if defined?(Unicorn) && Unicorn.respond_to?(:listener_names)
+          @@telegraf_host.write(direction: 'Raindrops', tags: {}, values: unicorn_stats)  unless unicorn_stats.blank?
           return @@telegraf_host.write(*args)
         end
       end
 
+      def self.unicorn_listener_stats ()
+        stats_hash = {}
+        stats_hash["total_active"] = 0
+        stats_hash["total_queued"] = 0
+
+        begin 
+          tmp = Unicorn.listener_names
+          unix = tmp.grep(%r{\A/})
+          tcp = tmp.grep(/\A.+:\d+\z/)
+          tcp = nil if tcp.empty?
+          unix = nil if unix.empty?
+
+
+          Raindrops::Linux.tcp_listener_stats(tcp).each do |addr,stats|
+            stats_hash["active_#{addr}"] = stats.active
+            stats_hash["queued_#{addr}"] = stats.queued
+            stats_hash["total_active"] = stats.active + stats_hash["total_active"]
+            stats_hash["total_queued"] = stats.queued + stats_hash["total_queued"]
+          end if tcp
+
+          Raindrops::Linux.unix_listener_stats(unix).each do |addr,stats|
+            stats_hash["active_#{addr}"] = stats.active
+            stats_hash["queued_#{addr}"] = stats.queued
+            stats_hash["total_active"] = stats.active + stats_hash["total_active"]
+            stats_hash["total_queued"] = stats.queued + stats_hash["total_queued"]
+          end if unix
+        rescue IOError => ex
+        rescue => ex
+          ZuoraConnect.logger.error(ex)
+        end
+        return stats_hash
+      end
+
       def self.get_metrics(type)
         @data = {}
 
@@ -280,13 +476,18 @@ module ZuoraConnect
         end
         return @data
       end
-    #### END Task Mathods ####
+    #### END Task Methods ####
 
-    #### START Task Mathods ####
+    #### START Task Methods ####
       def build_task(task_data: {}, session: {})
         session = {} if session.blank?
         self.task_data = task_data
         self.mode = self.task_data["mode"]
+
+        if task_data['id'].to_s != self.id.to_s
+          raise ZuoraConnect::Exceptions::MissMatch.new("Wrong Instance Identifier/Lookup")
+        end
+
         self.task_data.each do |k,v|
           if k.match(/^(.*)_login$/)
             tmp = ZuoraConnect::Login.new(v)
@@ -301,7 +502,7 @@ module ZuoraConnect
               else
                 tmp.client.current_session                       = session["#{self.id}::#{k}:current_session"]                             if session["#{self.id}::#{k}:current_session"]
                 tmp.client.bearer_token                          = session["#{self.id}::#{k}:bearer_token"]                                if session["#{self.id}::#{k}:bearer_token"] && tmp.client.respond_to?(:bearer_token) ## need incase session id goes from basic to aouth in same redis store
-                tmp.client.oauth_session_expires_at              = session["#{self.id}::#{k}:oauth_session_expires_at"]                    if session["#{self.id}::#{k}:oauth_session_expires_at"]  && tmp.client.respond_to?(:oauth_session_expires_at) 
+                tmp.client.oauth_session_expires_at              = session["#{self.id}::#{k}:oauth_session_expires_at"]                    if session["#{self.id}::#{k}:oauth_session_expires_at"]  && tmp.client.respond_to?(:oauth_session_expires_at)
               end
             end
             self.logins[k] = tmp
@@ -315,9 +516,17 @@ module ZuoraConnect
             self.locale = v["local"]
           end
         end
+      rescue ZuoraConnect::Exceptions::MissMatch => ex
+        raise
+      rescue ZuoraConnect::Exceptions::InvalidCredentialSet => ex 
+        raise
       rescue => ex
-        Rails.logger.error("Task Data: #{task_data}") if task_data.present?
-        Rails.logger.error("Task Session: #{session.to_h}") if session.present?
+        ZuoraConnect.logger.error("Build Task Error", ex)
+        ZuoraConnect.logger.error("Task Data: #{task_data}") if task_data.present?
+        if session.present?
+          ZuoraConnect.logger.error("Task Session: #{session.to_h}")  if session.methods.include?(:to_h)
+          ZuoraConnect.logger.error("Task Session: #{session.to_hash}") if session.methods.include?(:to_hash)
+        end
         raise
       end
 
@@ -339,11 +548,11 @@ module ZuoraConnect
           end
           return parsed_json
         elsif response.code == 400
-          raise ZuoraConnect::Exceptions::APIError.new(message: parsed_json['errors'].join(' '), response: response.body, code: response.code)
+          raise ZuoraConnect::Exceptions::APIError.new(message: parsed_json['errors'].join(' '), response: response)
         else
           raise ZuoraConnect::Exceptions::ConnectCommunicationError.new("Error Communicating with Connect", response.body, response.code)
         end
-      rescue *(ZuoraAPI::Login::CONNECTION_EXCEPTIONS).concat(ZuoraAPI::Login::CONNECTION_READ_EXCEPTIONS) => ex
+      rescue *(ZuoraAPI::Login::CONNECTION_EXCEPTIONS + ZuoraAPI::Login::CONNECTION_READ_EXCEPTIONS) => ex
         if (update_login_count += 1) < 3
           retry
         else
@@ -360,6 +569,47 @@ module ZuoraConnect
         end
       end
 
+      def fetch_org_details(debug: false)
+        details_count ||= 0
+        self.refresh if !defined?(self.target_login)
+
+        response = HTTParty.get("#{ZuoraConnect.configuration.url}/api/#{self.api_version}/tenants/search?hostname=#{self.target_login.client.hostname}&node_id=#{self.zuora_entity_ids.first}")
+       
+        if response.success?
+          parsed_json =  JSON.parse(response.body)
+          
+          #Set Org
+          if self.id >= 25000000 && parsed_json['organization'].present?
+            login_cache = self.zuora_logins
+            login_cache.delete('organization')
+            self.zuora_logins = login_cache.merge({'organizations' => [parsed_json['organization']]})
+          end
+          if defined?(ZuoraConnect::AppInstance::CONNECT_APPLICATION_ID)
+            downloads = parsed_json.fetch('downloads',[]).select{|a| a['applicationId'] == ZuoraConnect::AppInstance::CONNECT_APPLICATION_ID }.map { |h| h.slice('Name', 'provisionState') }
+            Rails.logger.info("Instance Downloads: #{downloads.to_s}") if debug
+            if downloads.size > 1
+              self.provision_status = 'MultipleProvisioningRecords'
+              self.provisioned_app = downloads.map {|d| d['Name']}.to_s
+            elsif downloads.size == 1
+              self.provision_status = downloads.first['provisionState']
+              self.provisioned_app = downloads.first['Name']
+            else
+              self.provision_status = 'NoProvisioningRecords'
+              self.provisioned_app = nil
+            end
+          end
+          self.save(:validate => false)
+         
+          return parsed_json
+        end
+      rescue *(ZuoraAPI::Login::CONNECTION_EXCEPTIONS + ZuoraAPI::Login::CONNECTION_READ_EXCEPTIONS) => ex
+        if (details_count += 1) < 3
+          retry
+        else
+          raise
+        end
+      end
+
       def update_task(options)
         update_task_count ||= 0
         response = HTTParty.post(ZuoraConnect.configuration.url + "/api/#{self.api_version}/tools/tasks/#{self.id}/update_task",:body => {:access_token => self.username}.merge(options))
@@ -367,11 +617,11 @@ module ZuoraConnect
         if response.code == 200
           return parsed_json
         elsif response.code == 400
-          raise ZuoraConnect::Exceptions::APIError.new(message: parsed_json['errors'].join(' '), response: response.body, code: response.code)
+          raise ZuoraConnect::Exceptions::APIError.new(message: parsed_json['errors'].join(' '), response: response)
         else
           raise ZuoraConnect::Exceptions::ConnectCommunicationError.new("Error Communicating with Connect", response.body, response.code)
         end
-      rescue *(ZuoraAPI::Login::CONNECTION_EXCEPTIONS).concat(ZuoraAPI::Login::CONNECTION_READ_EXCEPTIONS) => ex
+      rescue *(ZuoraAPI::Login::CONNECTION_EXCEPTIONS + ZuoraAPI::Login::CONNECTION_READ_EXCEPTIONS) => ex
         if (update_task_count += 1) < 3
           retry
         else
@@ -387,13 +637,13 @@ module ZuoraConnect
           raise
         end
       end
-    #### END Task Mathods ####
+    #### END Task Methods ####
 
-    #### START Connect OAUTH methods ####
-      def check_oauth_state(method)
+    #### START Connect OAUTH Methods ####
+      def check_oauth_state(method=nil)
         #Refresh token if already expired
         if self.oauth_expired?
-          Rails.logger.debug("[#{self.id}] Before '#{method}' method, Oauth expired")
+          ZuoraConnect.logger.debug("Before '#{method}' method, Oauth expired")
           self.refresh_oauth
         end
       end
@@ -403,16 +653,12 @@ module ZuoraConnect
       end
 
       def refresh_oauth
-        refresh_oauth_count ||= 0
-        start = Time.now
-        params = {
-                  :grant_type => "refresh_token",
-                  :redirect_uri => ZuoraConnect.configuration.oauth_client_redirect_uri,
-                  :refresh_token => self.refresh_token
-                }
-        response = HTTParty.post("#{ZuoraConnect.configuration.url}/oauth/token",:body => params)
-        response_time = Time.now - start
-        Rails.logger.info("[#{self.id}] REFRESH OAUTH - In #{response_time.round(2).to_s}")
+        refresh_oauth_count ||= 0        
+        response = HTTParty.post("#{ZuoraConnect.configuration.url}/oauth/token", body: {
+          :grant_type => "refresh_token",
+          :redirect_uri => ZuoraConnect.configuration.oauth_client_redirect_uri,
+          :refresh_token => self.refresh_token
+        })
 
         if response.code == 200
           response_body = JSON.parse(response.body)
@@ -422,15 +668,15 @@ module ZuoraConnect
           self.oauth_expires_at = Time.at(response_body["created_at"].to_i) + response_body["expires_in"].seconds
           self.save(:validate => false)
         else
-          Rails.logger.fatal("[#{self.id}] REFRESH OAUTH - Failed Code #{response.code}")
           raise ZuoraConnect::Exceptions::ConnectCommunicationError.new("Error Refreshing Access Token", response.body, response.code)
         end
-      rescue *(ZuoraAPI::Login::CONNECTION_EXCEPTIONS).concat(ZuoraAPI::Login::CONNECTION_READ_EXCEPTIONS) => ex
+      rescue *(ZuoraAPI::Login::CONNECTION_EXCEPTIONS + ZuoraAPI::Login::CONNECTION_READ_EXCEPTIONS) => ex
         if (refresh_oauth_count += 1) < 3
-          Rails.logger.info("[#{self.id}] REFRESH OAUTH - #{ex.class} Retrying(#{refresh_oauth_count})")
+          sleep(CONNECT_COMMUNICATION_SLEEP)
+          ZuoraConnect.logger.debug("REFRESH OAUTH - Connection Failure Retrying(#{refresh_oauth_count})", ex, self.default_ougai_items)
           retry
         else
-          Rails.logger.fatal("[#{self.id}] REFRESH OAUTH - #{ex.class} Failed #{refresh_oauth_count}x")
+          Rails.logger.fatal("REFRESH OAUTH - Connection Failed", ex, self.default_ougai_items)
           raise
         end
       rescue ZuoraConnect::Exceptions::ConnectCommunicationError => ex
@@ -441,14 +687,14 @@ module ZuoraConnect
         return if !self.oauth_expired?
 
         if (refresh_oauth_count += 1) < 3
-          Rails.logger.info("[#{self.id}] REFRESH OAUTH - Failed Retrying(#{refresh_oauth_count})")
+          ZuoraConnect.logger.debug("REFRESH OAUTH - Communication Failure Retrying(#{refresh_oauth_count})", ex, self.default_ougai_items)
           retry
         else
-          Rails.logger.fatal("[#{self.id}] REFRESH OAUTH - Failed #{refresh_oauth_count}x")
+          ZuoraConnect.logger.fatal("REFRESH OAUTH - Communication Failed #{ex.code}", ex, self.default_ougai_items)
           raise
         end
       end
-    #### END Connect OAUTH methods ####
+    #### END Connect OAUTH Methods ####
 
     #### START AppInstance Temporary Persistance Methods ####
       def marked_for_refresh?
@@ -486,7 +732,7 @@ module ZuoraConnect
           begin
             redis_get_command ||= 0
             cached_instance = Redis.current.get("AppInstance:#{self.id}")
-          rescue *(ZuoraAPI::Login::CONNECTION_EXCEPTIONS).concat(ZuoraAPI::Login::CONNECTION_READ_EXCEPTIONS) => ex
+          rescue *(ZuoraAPI::Login::CONNECTION_EXCEPTIONS + ZuoraAPI::Login::CONNECTION_READ_EXCEPTIONS) => ex
             if (redis_get_command += 1) < 3
               retry
             else
@@ -494,10 +740,10 @@ module ZuoraConnect
             end
           end
           if cached_instance.blank?
-            Rails.logger.debug("[#{self.id}] Cached AppInstance Missing")
+            ZuoraConnect.logger.debug("Cached AppInstance Missing", self.default_ougai_items)
             return session
           else
-            Rails.logger.debug("[#{self.id}] Cached AppInstance Found")
+            ZuoraConnect.logger.debug("Cached AppInstance Found", self.default_ougai_items)
             return decrypt_data(data: cached_instance, rescue_return: session).merge(session)
           end
         else
@@ -505,11 +751,15 @@ module ZuoraConnect
         end
       end
 
+      def delete_app_instance
+        Redis.current.del("AppInstance:#{self.id}")
+      end
+
       def cache_app_instance
         if defined?(Redis.current)
           #Task data must be present and the last refresh cannot be old. We dont want to overwite new cache data with old
           if self.task_data.present? &&  (self.last_refresh.to_i > INSTANCE_REFRESH_WINDOW.ago.to_i)
-            Rails.logger.debug("[#{self.id}] Caching AppInstance")
+            ZuoraConnect.logger.debug("Caching AppInstance", self.default_ougai_items)
             Redis.current.setex("AppInstance:#{self.id}", INSTANCE_REDIS_CACHE_PERIOD.to_i, self.encrypt_data(data: self.save_data))
           end
         end
@@ -536,12 +786,7 @@ module ZuoraConnect
 
         #Redis is not defined strip out old data
         if !defined?(Redis.current)
-          session["#{self.id}::task_data"].delete('applications')
-          session["#{self.id}::task_data"].delete('tenant_ids')
-          session["#{self.id}::task_data"].delete('organizations')
-          session["#{self.id}::task_data"].select {|k,v| k.include?('login') && v['tenant_type'] == 'Zuora'}.each do |login_key, login_data|
-            session["#{self.id}::task_data"][login_key]['entities'] = (login_data.dig('entities') || []).map {|entity| entity.slice('id', 'tenantId')}
-          end
+          strip_cache_data(object: session["#{self.id}::task_data"])
         end
 
         session["#{self.id}::last_refresh"] = self.last_refresh
@@ -549,6 +794,14 @@ module ZuoraConnect
         return session
       end
 
+      def strip_cache_data(object: {}, keys: ['applications', 'tokens','tenant_ids', 'organizations','user_settings'] )
+        keys.each {|key| object.delete(key) }
+        object.select {|k,v| k.include?('login') && v['tenant_type'] == 'Zuora'}.each do |login_key, login_data|
+          object[login_key]['entities'] = login_data.fetch('entities',[]).map {|entity| entity.slice('id', 'tenantId', 'entityId', 'displayName')}
+        end
+        return object
+      end
+
       def encryptor
         # Default values for Rails 4 apps
         key_iter_num, key_size, salt, signed_salt = [1000, 64, "encrypted cookie", "signed encrypted cookie"]
@@ -561,18 +814,19 @@ module ZuoraConnect
       def decrypt_data(data: nil, rescue_return: nil, log_fatal: true)
         return data if data.blank?
         if Rails.env == 'development'
-          begin 
+          begin
             return JSON.parse(data)
           rescue JSON::ParserError => ex
             return data
           end
         else
-          begin 
+          begin
             return JSON.parse(encryptor.decrypt_and_verify(CGI::unescape(data)))
           rescue ActiveSupport::MessageVerifier::InvalidSignature => ex
-            Rails.logger.add(Logger::FATAL, 'Error Decrypting') if log_fatal
+            ZuoraConnect.logger.error("Error Decrypting", ex, self.default_ougai_items) if log_fatal
             return rescue_return
           rescue JSON::ParserError => ex
+            ZuoraConnect.logger.error("JSON Parse Error", ex, self.default_ougai_items) if log_fatal
             return encryptor.decrypt_and_verify(CGI::unescape(data))
           end
         end
@@ -622,7 +876,7 @@ module ZuoraConnect
         if paused_user == current_user || paused_user.blank?
           Resque.redis.zrem("PauseQueue", "#{self.id}__#{paused_user}")
         else
-          raise "Can only unpause for user #{paused_user}." 
+          raise "Can only unpause for user #{paused_user}."
         end
       end
     ### END Resque Helping Methods ####
@@ -632,10 +886,10 @@ module ZuoraConnect
         self.update_column(:catalog_update_attempt_at, Time.now.utc)
 
         entity_reference = entity_id.blank? ? 'Default' : entity_id
-        Rails.logger.debug("Fetch Catalog")
-        Rails.logger.debug("Zuora Entity: #{entity_id.blank? ? 'default' : entity_id}")
+        ZuoraConnect.logger.debug("Fetch Catalog")
+        ZuoraConnect.logger.debug("Zuora Entity: #{entity_id.blank? ? 'default' : entity_id}")
 
-        login = zuora_login.client(entity_reference)
+        login = zuora_login.client(entity_id)
 
         old_logger = ActiveRecord::Base.logger
         ActiveRecord::Base.logger = nil
@@ -644,14 +898,8 @@ module ZuoraConnect
         response = {'nextPage' => login.rest_endpoint("catalog/products?pageSize=#{page_size}")}
         while !response["nextPage"].blank?
           url = login.rest_endpoint(response["nextPage"].split('/v1/').last)
-          Rails.logger.debug("Fetch Catalog URL #{url}")
-          output_json, response = login.rest_call(:debug => false, :url => url, :errors => [ZuoraAPI::Exceptions::ZuoraAPISessionError], :timeout_retry => true)
-          Rails.logger.debug("Fetch Catalog Response Code #{response.code}")
-
-          if !output_json['success'] =~ (/(true|t|yes|y|1)$/i) || output_json['success'].class != TrueClass
-            Rails.logger.error("Fetch Catalog DATA #{output_json.to_json}")
-            raise ZuoraAPI::Exceptions::ZuoraAPIError.new("Error Getting Catalog: #{output_json}")
-          end
+          ZuoraConnect.logger.debug("Fetch Catalog URL #{url}")
+          output_json, response = login.rest_call(:debug => false, :url => url, :timeout_retry => true)
 
           output_json["products"].each do |product|
             ActiveRecord::Base.connection.execute('UPDATE "public"."zuora_connect_app_instances" SET "catalog_mapping" = jsonb_set("catalog_mapping", \'{tmp, %s}\', \'%s\') where "id" = %s' % [product["id"], {"productId" => product["id"]}.to_json.gsub("'", "''"), self.id])
@@ -836,7 +1084,7 @@ module ZuoraConnect
           if cache
             Redis.current.sadd("Catalog:#{self.id}:Keys", ["Catalog:#{self.id}:#{object_id}:Hierarchy", "Catalog:#{self.id}:#{object_id}:Children:#{child_objects}"])
             Redis.current.set("Catalog:#{self.id}:#{object_id}:Hierarchy", encrypt_data(data: object_hierarchy))
-            Redis.current.set("Catalog:#{self.id}:#{object_id}:Children:#{child_objects}", encrypt_data(data: stub_catalog)) 
+            Redis.current.set("Catalog:#{self.id}:#{object_id}:Children:#{child_objects}", encrypt_data(data: stub_catalog))
           else
             Redis.current.sadd("Catalog:#{self.id}:Keys", ["Catalog:#{self.id}:#{object_id}:Hierarchy"])
             Redis.current.set("Catalog:#{self.id}:#{object_id}:Hierarchy", encrypt_data(data: object_hierarchy))
@@ -871,17 +1119,32 @@ module ZuoraConnect
     ### END S3 Helping Methods #####
 
     ### START Aggregate Grouping Helping Methods ####
-      def self.refresh_aggregate_table(aggregate_name: 'all_tasks_processing', table_name: 'tasks', where_clause: "where status in ('Processing', 'Queued')", index_table: true)
+      # Traverse entire database and run a query on table(table_name) with where clause(where_clause)
+      # Data from each schema will be loaded into table(aggregate_name) into the public schema
+      def self.refresh_aggregate_table(aggregate_name: 'all_tasks_processing', table_name: 'tasks', where_clause: "where status in ('Processing', 'Queued')", index_table: true, ignore_indexes: [])
         self.update_functions
+
+        sql_result = ActiveRecord::Base.connection.execute <<-eos
+          SELECT pid, relname, mode
+          FROM pg_locks l
+          JOIN pg_class t ON l.relation = t.oid AND t.relkind = 'r'
+          WHERE t.relname = '#{aggregate_name}' AND l.mode ='AccessExclusiveLock';
+        eos
+        raise ZuoraConnect::Exceptions::Error.new("An existing lock detected while dropping table '#{aggregate_name}'") if sql_result.count > 0
+
         if index_table
-          ActiveRecord::Base.connection.execute('SELECT "shared_extensions".refresh_aggregate_table(\'%s\', \'%s\', %s, \'Index\');' % [aggregate_name, table_name, ActiveRecord::Base.connection.quote(where_clause)])
-        else 
-          ActiveRecord::Base.connection.execute('SELECT "shared_extensions".refresh_aggregate_table(\'%s\', \'%s\', %s, \'NO\');' % [aggregate_name, table_name, ActiveRecord::Base.connection.quote(where_clause)])
+          ActiveRecord::Base.connection.execute('SELECT "shared_extensions".refresh_aggregate_table(\'%s\', \'%s\', %s, \'Index\', \'{%s}\');' % [aggregate_name, table_name, ActiveRecord::Base.connection.quote(where_clause), ignore_indexes.map { |index| "\"#{index}\"" }.join(',')])
+        else
+          ActiveRecord::Base.connection.execute('SELECT "shared_extensions".refresh_aggregate_table(\'%s\', \'%s\', %s, \'NO\',\'{}\');' % [aggregate_name, table_name, ActiveRecord::Base.connection.quote(where_clause)])
         end
       end
 
+      # Load a psql script as a function in a transaction lock
       def self.update_functions
-        ActiveRecord::Base.connection.execute(File.read("#{Gem.loaded_specs["zuora_connect"].gem_dir}/app/views/sql/refresh_aggregate_table.txt"))
+        ActiveRecord::Base.transaction do
+          ActiveRecord::Base.connection.execute("SELECT pg_advisory_xact_lock(#{Zlib.crc32('refresh_aggregate_table')})")
+          ActiveRecord::Base.connection.execute(File.read("#{Gem.loaded_specs["zuora_connect"].gem_dir}/app/views/sql/refresh_aggregate_table.txt"))
+        end
       end
     ### END Aggregate Grouping Helping Methods #####
 
@@ -904,13 +1167,15 @@ module ZuoraConnect
     end
 
     def reload_attributes(selected_attributes)
-      raise "Attibutes must be array" if selected_attributes.class != Array
-      value_attributes = self.class.unscoped.where(:id=>id).select(selected_attributes).first.attributes
+      raise "Attibutes must be array" unless selected_attributes.is_a?(Array)
+      selected_attributes.push(:organizations, :environment, :zuora_tenant_ids)
+      selected_attributes.uniq!
+      value_attributes = self.class.unscoped.where(id: id).select(selected_attributes).first.attributes
       value_attributes.each do |key, value|
         next if key == "id" && value.blank?
         self.send(:write_attribute, key, value)
       end
-      return self
+      self
     end
 
     def instance_failure(failure)
@@ -939,14 +1204,32 @@ module ZuoraConnect
 
     def method_missing(method_sym, *arguments, &block)
       if method_sym.to_s.include?("login")
-        Rails.logger.fatal("Method Missing #{method_sym}")
-        Rails.logger.fatal("Instance Data: #{self.task_data}")
-        Rails.logger.fatal("Instance Logins: #{self.logins}")
+        ZuoraConnect.logger.fatal("Method Missing #{method_sym}. Instance Data: #{self.task_data} Instance Logins: #{self.logins}")
       end
       super
     end
 
-    method_hook :refresh, :updateOption, :update_logins, :before => :check_oauth_state
+    def self.read_master_db
+      if self.connection.respond_to?(:stick_to_master!)
+        self.connection.stick_to_master!(false)
+        yield
+        Makara::Context.release_all
+      else
+        yield
+      end
+    end
+
+    def self.without_sticking
+       if self.connection.respond_to?(:without_sticking)
+        self.connection.without_sticking do 
+          yield
+        end
+      else
+        yield
+      end
+    end
+
+    method_hook :updateOption, :update_logins, :before => :check_oauth_state
     method_hook :new_session, :refresh, :build_task, :after => :apartment_switch
   end
-end
+end