zuora_connect 1.7.88 → 1.7.710

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 11f1348874bf62e15aeb9092fa9b25e77de1dd90ac7191df41e0e39667213327
-  data.tar.gz: 617d33f5a972d3db906ccd3c1645029a0070d8765fa2c9997d4286b987705ee0
+SHA1:
+  metadata.gz: e96d28bc77c7265cd2ba00b34fda0f2c278561b2
+  data.tar.gz: 57b1a0d66be1148960ecf5322ea5710ee9d55d62
 SHA512:
-  metadata.gz: 74fae048271c9d725dd7464d60d63aad302ea559f1b854e18a3bdda6684f4a2eec9587916354bb68e0cb30308e62739ff2bd5118d5984cd6142afe932299d954
-  data.tar.gz: 674e394987cb0310178c57d45b41bc7d8353612c98feb17a35457e98e2c701bd588645c51c658dbd6d2ca94c11a03d4dfa0b3c3b5d62212701f21e268d26195a
+  metadata.gz: 041ff1a6cd3eb7e5716b069f5b60bb78f07a976d6000876c20adbf623aaad5f150d78ef19c7ec0d1a3e53c865c0e79579f53cbafaf06c7d92e00eaf822523643
+  data.tar.gz: 370c8b43ee1fc8a6c7a58a6b64c61430ff428478d14ffc894bd90738dde85517a37204de7a8f5d9157870b8bb24748e6e9af4bfe8dcbe6e8aa8bd23bafe532d7

data/app/controllers/zuora_connect/api/v1/app_instance_controller.rb

@@ -41,18 +41,5 @@ module ZuoraConnect
 
     end
 
-    def cache_bust
-      if defined?(Redis.current)
-        Redis.current.del("AppInstance:#{@appinstance.id}")
-        respond_to do |format|
-          format.json {render json: {}, status: :ok}
-        end
-      else
-        respond_to do |format|
-          format.json {render json: {}, status: :bad_request}
-        end
-      end
-    end
-
   end
 end

data/app/controllers/zuora_connect/static_controller.rb

@@ -1,10 +1,10 @@
 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_filter :authenticate_connect_app_request, :except => [:metrics, :health, :session_error, :invalid_app_instance_error, :initialize_app]
+    before_filter :clear_connect_app_session,        :only =>   [:metrics, :health, :session_error, :invalid_app_instance_error, :initialize_app]
+    after_filter :persist_connect_app_session,       :except => [:metrics, :health, :session_error, :invalid_app_instance_error, :initialize_app]
     
-    skip_before_action :verify_authenticity_token, :only => [:initialize_app]
+    skip_before_filter :verify_authenticity_token, :only => [:initialize_app]
 
     def session_error
       respond_to do |format|
@@ -26,19 +26,6 @@ module ZuoraConnect
     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(ex)
-          when 'Exception'
-            raise
-          end
-        end
-      end
-
       render json: {
         message: "Alive",
         status: 200
@@ -55,8 +42,8 @@ module ZuoraConnect
       rescue
         render json: {
           message: "Failure initializing app instance",
-          status: 500
-        }, status: 500
+          status: 400
+        }, status: 400
       end
     end
 

data/app/models/zuora_connect/app_instance_base.rb

@@ -4,7 +4,6 @@ module ZuoraConnect
     default_scope {select(ZuoraConnect::AppInstance.column_names.delete_if {|x| ["catalog_mapping", "catalog"].include?(x) }) }
     after_initialize :init
     after_create :initialize_redis_placeholder
-    before_destroy :prune_data
 
     self.table_name = "zuora_connect_app_instances"
     attr_accessor :options, :mode, :logins, :task_data, :last_refresh, :username, :password, :s3_client, :api_version, :drop_message, :new_session_message, :connect_user, :logitems
@@ -16,7 +15,6 @@ module ZuoraConnect
     BLANK_OBJECT_ID_LOOKUP = 'BlankValueSupplied'
     HOLDING_PATTERN_SLEEP = 5.seconds
     CONNECT_COMMUNICATION_SLEEP= 5.seconds
-    IGNORED_LOCALS = ['fr', 'ja', 'sp']
 
     def init
       self.connect_user = 'Nobody'
@@ -28,9 +26,9 @@ 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) && ElasticAPM.running?
+      if defined?(ElasticAPM)
         ElasticAPM.set_user("Backend")
-        ElasticAPM.set_tag(:app_instance, self.id)
+        ElasticAPM.set_tag(:app_instance, self.id) 
       end
 
       if INSTANCE_REFRESH_WINDOW > INSTANCE_REDIS_CACHE_PERIOD
@@ -41,7 +39,6 @@ module ZuoraConnect
 
     def initialize_redis_placeholder
       if defined?(Redis.current)
-        Redis.current.zrem("AppInstance:Deleted", id)
         Redis.current.zadd("APILimits", 9999999999, "placeholder")
         Redis.current.zadd("InstanceRefreshing", 9999999999, "placeholder")
       end
@@ -50,39 +47,18 @@ module ZuoraConnect
       end
     end
 
-    def prune_data(id: self.id)
-      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)
-      end
-      if defined?(Resque.redis)
-        Resque.redis.zrem("PauseQueue", id)
-      end
-      return true
-    end
-
     def apartment_switch(method = nil, migrate = false)
-      switch_count ||= 0
-      if self.persisted?
+      begin
+        Apartment::Tenant.switch!(self.id) if self.persisted?
+      rescue Apartment::TenantNotFound => ex
         begin
-          Apartment::Tenant.switch!(self.id)
-        rescue Apartment::TenantNotFound => ex
-          sleep(2)
-          begin
-            Apartment::Tenant.create(self.id.to_s)
-          rescue Apartment::TenantExists => ex
-          end
-          if (switch_count += 1) < 2
-            retry
-          else
-            raise
-          end
-        end
-        if migrate && ActiveRecord::Migrator.needs_migration?
-          Apartment::Migrator.migrate(self.id)
+          Apartment::Tenant.create(self.id.to_s)
+        rescue Apartment::TenantExists => ex
         end
+        retry
+      end
+      if migrate && ActiveRecord::Migrator.needs_migration?
+        Apartment::Migrator.migrate(self.id)
       end
       Thread.current[:appinstance] = self
     end
@@ -94,7 +70,7 @@ module ZuoraConnect
       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.running?
+      ElasticAPM.set_user(self.connect_user)   if defined?(ElasticAPM) 
       recoverable_session = false
 
       ## DEV MODE TASK DATA MOCKUP
@@ -121,26 +97,26 @@ module ZuoraConnect
 
         if session.empty?
           self.new_session_message = "REFRESHING - Session Empty"
-          ZuoraConnect.logger.add(log_level, self.new_session_message)
+          Rails.logger.add(log_level, 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})"
-          ZuoraConnect.logger.add(log_level, self.new_session_message)
+          Rails.logger.add(log_level, 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"
-          ZuoraConnect.logger.add(log_level, self.new_session_message)
+          Rails.logger.add(log_level, 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
-          ZuoraConnect.logger.add(log_level, self.new_session_message)
+          Rails.logger.add(log_level, self.new_session_message)
           raise ZuoraConnect::Exceptions::HoldingPattern if holding_pattern && !self.mark_for_refresh
           self.refresh(session: session)
 
@@ -148,7 +124,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
-          ZuoraConnect.logger.add(log_level, self.new_session_message)
+          Rails.logger.add(log_level, self.new_session_message)
           self.refresh(session: session)
 
         else
@@ -157,22 +133,22 @@ module ZuoraConnect
           else
             self.new_session_message = "REBUILDING - Expires in #{time_expire} seconds"
           end
-          ZuoraConnect.logger.add(log_level, self.new_session_message)
+          Rails.logger.add(log_level, self.new_session_message)
           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?
-        ZuoraConnect.logger.info("Holding - Expires in #{self.reset_mark_expires_at}. '#{self.new_session_message}'")
+        Rails.logger.info("Holding - Expires in #{self.reset_mark_expires_at}. '#{self.new_session_message}'")
         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 => ex 
       if recoverable_session
-        ZuoraConnect.logger.warn("REBUILDING - Using backup expired cache")
+        Rails.logger.error("REBUILDING - Using backup expired cache")
         self.build_task(task_data: session["#{self.id}::task_data"], session: session)
         return self
       else
@@ -182,17 +158,17 @@ module ZuoraConnect
       begin
         I18n.locale = self.locale
       rescue I18n::InvalidLocale => ex
-        ZuoraConnect.logger.error(ex) if !IGNORED_LOCALS.include?(ex.locale.to_s.downcase)
+        Rails.logger.debug("Invalid Locale: #{ex.message}")
       end
       Time.zone = self.timezone
       tenants = self.task_data.dig('tenant_ids') || []
       organizations = self.task_data.dig('organizations') || []
-      if defined?(ElasticAPM) && ElasticAPM.running?
+      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
+      self.update_column(:name, self.task_data.dig('name')) if ZuoraConnect::AppInstance.column_names.include?('name') && self.task_data.dig('name') != self.name 
     end
 
     def refresh(session: {}, session_fallback: false)
@@ -201,34 +177,33 @@ module ZuoraConnect
       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
 
-      ZuoraConnect.logger.debug("[#{self.id}] REFRESH TASK - Connect Task Info Request Time #{response_time.round(2).to_s}")
+      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.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)
       end
     rescue *(ZuoraAPI::Login::CONNECTION_EXCEPTIONS).concat(ZuoraAPI::Login::CONNECTION_READ_EXCEPTIONS) => ex
       if (refresh_count += 1) < 3
-        ZuoraConnect.logger.info("[#{self.id}] REFRESH TASK - #{ex.class} Retrying(#{refresh_count})")
+        Rails.logger.info("[#{self.id}] REFRESH TASK - #{ex.class} Retrying(#{refresh_count})")
         retry
       else
-        ZuoraConnect.logger.fatal("[#{self.id}] REFRESH TASK - #{ex.class} Failed #{refresh_count}x")
+        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
-          ZuoraConnect.logger.info("[#{self.id}] REFRESH TASK - Failed #{ex.code} - Retrying(#{refresh_count})")
           self.refresh_oauth
-        else
-          ZuoraConnect.logger.warn("[#{self.id}] REFRESH TASK - Failed #{ex.code} - Retrying(#{refresh_count})")
         end
         retry
       else
-        ZuoraConnect.logger.fatal("[#{self.id}] REFRESH TASK - Failed #{ex.code} - #{refresh_count}x")
+        Rails.logger.fatal("[#{self.id}] REFRESH TASK - Failed #{refresh_count}x")
         raise
       end
     end
@@ -245,45 +220,10 @@ 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 = {}
 
@@ -338,7 +278,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
@@ -353,11 +293,8 @@ module ZuoraConnect
           end
         end
       rescue => 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
+        Rails.logger.error("Task Data: #{task_data}") if task_data.present?
+        Rails.logger.error("Task Session: #{session.to_h}") if session.present?
         raise
       end
 
@@ -433,7 +370,7 @@ module ZuoraConnect
       def check_oauth_state(method)
         #Refresh token if already expired
         if self.oauth_expired?
-          ZuoraConnect.logger.debug("[#{self.id}] Before '#{method}' method, Oauth expired")
+          Rails.logger.debug("[#{self.id}] Before '#{method}' method, Oauth expired")
           self.refresh_oauth
         end
       end
@@ -452,7 +389,7 @@ module ZuoraConnect
                 }
         response = HTTParty.post("#{ZuoraConnect.configuration.url}/oauth/token",:body => params)
         response_time = Time.now - start
-        ZuoraConnect.logger.debug("[#{self.id}] REFRESH OAUTH - In #{response_time.round(2).to_s}")
+        Rails.logger.info("[#{self.id}] REFRESH OAUTH - In #{response_time.round(2).to_s}")
 
         if response.code == 200
           response_body = JSON.parse(response.body)
@@ -462,14 +399,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
-          raise ZuoraConnect::Exceptions::ConnectCommunicationError.new("Error Refreshing Access Token for #{self.id}", response.body, response.code)
+          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
         if (refresh_oauth_count += 1) < 3
-          ZuoraConnect.logger.info("[#{self.id}] REFRESH OAUTH - #{ex.class} Retrying(#{refresh_oauth_count})")
+          Rails.logger.info("[#{self.id}] REFRESH OAUTH - #{ex.class} Retrying(#{refresh_oauth_count})")
           retry
         else
-          ZuoraConnect.logger.fatal("[#{self.id}] REFRESH OAUTH - #{ex.class} Failed #{refresh_oauth_count}x")
+          Rails.logger.fatal("[#{self.id}] REFRESH OAUTH - #{ex.class} Failed #{refresh_oauth_count}x")
           raise
         end
       rescue ZuoraConnect::Exceptions::ConnectCommunicationError => ex
@@ -480,10 +418,10 @@ module ZuoraConnect
         return if !self.oauth_expired?
 
         if (refresh_oauth_count += 1) < 3
-          ZuoraConnect.logger.info("[#{self.id}] REFRESH OAUTH - Failed #{ex.code} - Retrying(#{refresh_oauth_count})")
+          Rails.logger.info("[#{self.id}] REFRESH OAUTH - Failed Retrying(#{refresh_oauth_count})")
           retry
         else
-          ZuoraConnect.logger.fatal("[#{self.id}] REFRESH OAUTH - Failed #{ex.code} - #{refresh_oauth_count}x")
+          Rails.logger.fatal("[#{self.id}] REFRESH OAUTH - Failed #{refresh_oauth_count}x")
           raise
         end
       end
@@ -533,10 +471,10 @@ module ZuoraConnect
             end
           end
           if cached_instance.blank?
-            ZuoraConnect.logger.debug("[#{self.id}] Cached AppInstance Missing")
+            Rails.logger.debug("[#{self.id}] Cached AppInstance Missing")
             return session
           else
-            ZuoraConnect.logger.debug("[#{self.id}] Cached AppInstance Found")
+            Rails.logger.debug("[#{self.id}] Cached AppInstance Found")
             return decrypt_data(data: cached_instance, rescue_return: session).merge(session)
           end
         else
@@ -548,7 +486,7 @@ module ZuoraConnect
         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)
-            ZuoraConnect.logger.debug("[#{self.id}] Caching AppInstance")
+            Rails.logger.debug("[#{self.id}] Caching AppInstance")
             Redis.current.setex("AppInstance:#{self.id}", INSTANCE_REDIS_CACHE_PERIOD.to_i, self.encrypt_data(data: self.save_data))
           end
         end
@@ -600,16 +538,16 @@ 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
-            ZuoraConnect.logger.add(Logger::ERROR, "Error Decrypting for #{self.id}") if log_fatal
+            Rails.logger.add(Logger::FATAL, 'Error Decrypting') if log_fatal
             return rescue_return
           rescue JSON::ParserError => ex
             return encryptor.decrypt_and_verify(CGI::unescape(data))
@@ -661,7 +599,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 ####
@@ -671,8 +609,8 @@ module ZuoraConnect
         self.update_column(:catalog_update_attempt_at, Time.now.utc)
 
         entity_reference = entity_id.blank? ? 'Default' : entity_id
-        ZuoraConnect.logger.debug("Fetch Catalog")
-        ZuoraConnect.logger.debug("Zuora Entity: #{entity_id.blank? ? 'default' : entity_id}")
+        Rails.logger.debug("Fetch Catalog")
+        Rails.logger.debug("Zuora Entity: #{entity_id.blank? ? 'default' : entity_id}")
 
         login = zuora_login.client(entity_reference)
 
@@ -683,12 +621,12 @@ 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)
-          ZuoraConnect.logger.debug("Fetch Catalog URL #{url}")
+          Rails.logger.debug("Fetch Catalog URL #{url}")
           output_json, response = login.rest_call(:debug => false, :url => url, :errors => [ZuoraAPI::Exceptions::ZuoraAPISessionError], :timeout_retry => true)
-          ZuoraConnect.logger.debug("Fetch Catalog Response Code #{response.code}")
+          Rails.logger.debug("Fetch Catalog Response Code #{response.code}")
 
           if !output_json['success'] =~ (/(true|t|yes|y|1)$/i) || output_json['success'].class != TrueClass
-            ZuoraConnect.logger.error("Fetch Catalog DATA #{output_json.to_json}")
+            Rails.logger.error("Fetch Catalog DATA #{output_json.to_json}")
             raise ZuoraAPI::Exceptions::ZuoraAPIError.new("Error Getting Catalog: #{output_json}")
           end
 
@@ -875,7 +813,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))
@@ -914,7 +852,7 @@ module ZuoraConnect
         self.update_functions
         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
+        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
@@ -978,9 +916,9 @@ module ZuoraConnect
 
     def method_missing(method_sym, *arguments, &block)
       if method_sym.to_s.include?("login")
-        ZuoraConnect.logger.fatal("Method Missing #{method_sym}")
-        ZuoraConnect.logger.fatal("Instance Data: #{self.task_data}")
-        ZuoraConnect.logger.fatal("Instance Logins: #{self.logins}")
+        Rails.logger.fatal("Method Missing #{method_sym}")
+        Rails.logger.fatal("Instance Data: #{self.task_data}")
+        Rails.logger.fatal("Instance Logins: #{self.logins}")
       end
       super
     end
@@ -988,4 +926,4 @@ module ZuoraConnect
     method_hook :refresh, :updateOption, :update_logins, :before => :check_oauth_state
     method_hook :new_session, :refresh, :build_task, :after => :apartment_switch
   end
-end
+end

data/app/models/zuora_connect/telegraf.rb

@@ -12,14 +12,14 @@ module ZuoraConnect
     end
 
     def connect
-      ZuoraConnect.logger.debug(self.format_metric_log('Telegraf','Need new connection')) if ZuoraConnect.configuration.telegraf_debug
+      Rails.logger.debug(self.format_metric_log('Telegraf','Need new connection')) if ZuoraConnect.configuration.telegraf_debug
       uri = URI.parse(ZuoraConnect.configuration.telegraf_endpoint)
       self.host = UDPSocket.new.tap do |socket|
         socket.connect uri.host, uri.port
       end
     rescue => ex
       self.host = nil
-      ZuoraConnect.logger.warn(self.format_metric_log('Telegraf', "Failed to connect: #{ex.class}"))
+      Rails.logger.warn(self.format_metric_log('Telegraf', "Failed to connect: #{ex.class}"))
     end
 
     def write(direction: 'Unknown', tags: {}, values: {})
@@ -44,9 +44,9 @@ module ZuoraConnect
         end
       end
       if ZuoraConnect.configuration.telegraf_debug
-        ZuoraConnect.logger.debug(self.format_metric_log('Telegraf', tags.to_s))
-        ZuoraConnect.logger.debug(self.format_metric_log('Telegraf', values.to_s))
-        ZuoraConnect.logger.debug(self.format_metric_log('Telegraf', "Writing '#{direction.capitalize}': #{time.real.round(5)} ms"))
+        Rails.logger.debug(self.format_metric_log('Telegraf', tags.to_s))
+        Rails.logger.debug(self.format_metric_log('Telegraf', values.to_s))
+        Rails.logger.debug(self.format_metric_log('Telegraf', "Writing '#{direction.capitalize}': #{time.real.round(5)} ms"))
       end
     end
 
@@ -56,18 +56,14 @@ module ZuoraConnect
       self.host.write InfluxDB::PointValue.new({series: series, tags: tags, values: values}).dump 
     rescue => ex
       self.connect
-      ZuoraConnect.logger.warn(self.format_metric_log('Telegraf',"Failed to write udp: #{ex.class}"))
+      Rails.logger.warn(self.format_metric_log('Telegraf',"Failed to write udp: #{ex.class}"))
     end
 
     def format_metric_log(message, dump = nil)
       message_color, dump_color = "1;91", "0;1"
       log_entry = "  \e[#{message_color}m#{message}\e[0m   "
       log_entry << "\e[#{dump_color}m%#{String === dump ? 's' : 'p'}\e[0m" % dump if dump
-      if Rails.env == :development
-        log_entry
-      else
-        [message, dump].compact.join(' - ')
-      end
+      log_entry
     end
 
     def self.app_name

data/config/initializers/redis.rb

@@ -1,9 +1,9 @@
 redis_url = ENV["REDIS_URL"].present? ?  ENV["REDIS_URL"] : defined?(Rails.application.secrets.redis) ? Rails.application.secrets.redis : 'redis://localhost:6379/1'
 resque_url = ENV["RESQUE_URL"].present? ?  ENV["RESQUE_URL"] : defined?(Rails.application.secrets.resque) ? Rails.application.secrets.resque : 'redis://localhost:6379/1'
 if defined?(Redis.current)
-  Redis.current = Redis.new(:id => "#{ZuoraConnect::Telegraf.full_process_name(process_name: 'Redis')}", :url => redis_url, :timeout => 6, :reconnect_attempts => 2)
+  Redis.current = Redis.new(:id => "#{ZuoraConnect::Telegraf.full_process_name(process_name: 'Redis')}", :url => redis_url, :timeout => 10, :reconnect_attempts => 2)
   if defined?(Resque.redis)
-    Resque.redis = resque_url != redis_url ? Redis.new(:id => "#{ZuoraConnect::Telegraf.full_process_name(process_name: 'Resque')}", :url => resque_url, :timeout => 6, :reconnect_attempts => 2) : Redis.current
+    Resque.redis = resque_url != redis_url ? Redis.new(:id => "#{ZuoraConnect::Telegraf.full_process_name(process_name: 'Resque')}", :url => resque_url, :timeout => 10, :reconnect_attempts => 2) : Redis.current
   end
 end
 if defined?(RedisBrowser)

data/config/initializers/resque.rb

@@ -19,13 +19,4 @@ Resque.module_eval do
 
     Hash[queue_names.zip(sizes)]
   end
-end
-
-if defined?(Resque)
-  Resque.logger = ZuoraConnect.custom_logger(name: "Resque", type: 'Monologger', level: MonoLogger::INFO) 
-  Resque::Scheduler.logger = ZuoraConnect.custom_logger(name: "ResqueScheduler") if defined?(Resque::Scheduler)
-end
-
-Makara::Logging::Logger.logger = ZuoraConnect.custom_logger(name: "Makara") if defined?(Makara)
-ElasticAPM.agent.config.logger = ZuoraConnect.custom_logger(name: "ElasticAPM", level: MonoLogger::WARN) if defined?(ElasticAPM) && ElasticAPM.running?
-ActionMailer::Base.logger = ZuoraConnect.custom_logger(name: "ActionMailer", type: 'Monologger') if defined?(ActionMailer)
+end

data/config/routes.rb

@@ -9,7 +9,6 @@ ZuoraConnect::Engine.routes.draw do
     namespace :v1 do
       resources :app_instance, :only => [:index], defaults: {format: :json} do
           match "drop", via: [:get, :post], on: :collection
-          match "cache_bust", via: [:get, :post], on: :collection
       end
     end
   end

data/db/migrate/20100718151733_create_connect_app_instances.rb

@@ -1,4 +1,4 @@
-class CreateConnectAppInstances < ActiveRecord::Migration
+class CreateConnectAppInstances < ActiveRecord::Migration[4.2]
   def change
     if !ActiveRecord::Base.connection.table_exists?('zuora_connect_app_instances')
       create_table :zuora_connect_app_instances do |t|

data/db/migrate/20101024162319_add_tokens_to_app_instance.rb

@@ -1,4 +1,4 @@
-class AddTokensToAppInstance < ActiveRecord::Migration
+class AddTokensToAppInstance < ActiveRecord::Migration[4.2]
   def change
     add_column :zuora_connect_app_instances, :access_token, :string unless column_exists? :zuora_connect_app_instances, :access_token
     add_column :zuora_connect_app_instances, :refresh_token, :string unless column_exists? :zuora_connect_app_instances, :refresh_token

data/db/migrate/20101024220705_add_token_to_app_instance.rb

@@ -1,4 +1,4 @@
-class AddTokenToAppInstance < ActiveRecord::Migration
+class AddTokenToAppInstance < ActiveRecord::Migration[4.2]
   def change
     add_column :zuora_connect_app_instances, :token, :string  unless column_exists? :zuora_connect_app_instances, :token
   end

data/db/migrate/20110131211919_add_sessions_table.rb

@@ -1,4 +1,4 @@
-class AddSessionsTable < ActiveRecord::Migration
+class AddSessionsTable < ActiveRecord::Migration[4.2]
   def change
     if !ActiveRecord::Base.connection.table_exists?('sessions')
       create_table :sessions do |t|

data/db/migrate/20110411200303_add_expiration_to_app_instance.rb

@@ -1,4 +1,4 @@
-class AddExpirationToAppInstance < ActiveRecord::Migration
+class AddExpirationToAppInstance < ActiveRecord::Migration[4.2]
   def change
     add_column :zuora_connect_app_instances, :oauth_expires_at, :datetime  unless column_exists? :zuora_connect_app_instances, :oauth_expires_at
   end