zuora_connect 2.0.60u → 3.0.0l

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 92a983cff8e7ff831929da9496cbb34e728f2033e79135c8bb76fa604bd33e71
-  data.tar.gz: 67170a20afb4fee284cc402484e5770b47422ebbeb7652dca39ceab862ca4d20
+  metadata.gz: b9a8f69b209e1762d0c1972e864b17330becc946114bd8c78313bf5221e7f4fc
+  data.tar.gz: ff25b1fe4224b67bd2e8c387406a04237b9828e3e21adf3ed75ab282694f061d
 SHA512:
-  metadata.gz: cb814342311b45d90903a72fff8d7bb9d313b91fb89346e99039276af4aae03ed538841215c9737ebc237d80a3584f3955c6e30e48a8e0c322ba7c7fd145ad78
-  data.tar.gz: 8f3d002f881cc6403baaae4f00bb88c8fff0f063c4a6290f4ad2c02c49361afe037717c6a55823a1834a9b29e3f16f11b2339211b992f83c42042133ebe33c55
+  metadata.gz: 13fb0d5ad358b91fa77a23fe72091482df39bf2dbd5acc846419666550d7f1d1078cf1e150444237c3554eebb1c8d6484beec541562ce1e5180507a1cbd8a6da
+  data.tar.gz: 99007a267042763f665a2d195e160682a346d96388f081c548f26c6730a7c0ef6adc9633e9576f230ac4665e91e073289de110a212e9f41f66e964704e55e6f1

data/Rakefile

@@ -15,7 +15,7 @@ RDoc::Task.new(:rdoc) do |rdoc|
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
-APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
 load 'rails/tasks/engine.rake'
 
 

data/app/controllers/zuora_connect/static_controller.rb

@@ -1,16 +1,12 @@
 module ZuoraConnect
   class StaticController < ApplicationController
-    before_action :authenticate_connect_app_request, :except => [:metrics, :health, :initialize_app, :provision, :instance_user]
-    before_action :clear_connect_app_session,        :only =>   [:metrics, :health, :initialize_app, :provision, :instance_user]
-    after_action :persist_connect_app_session,       :except => [:metrics, :health, :initialize_app, :provision, :instance_user]
+    before_action :authenticate_connect_app_request, :except => [:health, :initialize_app, :provision, :instance_user]
+    before_action :clear_connect_app_session,        :only =>   [:health, :initialize_app, :provision, :instance_user]
+    after_action :persist_connect_app_session,       :except => [:health, :initialize_app, :provision, :instance_user]
 
     skip_before_action :verify_authenticity_token, :only => [:initialize_app, :provision]
     http_basic_authenticate_with name: ENV['PROVISION_USER'], password: ENV['PROVISION_SECRET'], :only => [:provision, :instance_user]
 
-    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?

data/app/models/zuora_connect/app_instance_base.rb

@@ -12,7 +12,6 @@ module ZuoraConnect
 
     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, :user_timezone
-    @@telegraf_host = nil
     REFRESH_TIMEOUT = 2.minute                #Used to determine how long to wait on current refresh call before executing another
     INSTANCE_REFRESH_WINDOW = 1.hours         #Used to set how how long till app starts attempting to refresh cached task connect data
     INSTANCE_REDIS_CACHE_PERIOD = 24.hours    #Used to determine how long to cached task data will live for
@@ -35,7 +34,7 @@ module ZuoraConnect
       Aws::Errors::MissingCredentialsError,
       Aws::S3::Errors::AccessDenied,
       Aws::SES::Errors::AccessDenied,
-      Aws::KMS::Errors::AccessDeniedException 
+      Aws::KMS::Errors::AccessDeniedException
     ].freeze
     AWS_AUTH_ERRORS_MSG = "AWS Auth Errors".freeze
 
@@ -153,7 +152,8 @@ module ZuoraConnect
       if ZuoraConnect.configuration.mode != "Production"
         mock_task_data = {
           "id" => ZuoraConnect.configuration.dev_mode_appinstance,
-          "mode" => ZuoraConnect.configuration.dev_mode_mode
+          "mode" => ZuoraConnect.configuration.dev_mode_mode,
+          "name" => "Developer Instance"
         }
 
         case ZuoraConnect.configuration.dev_mode_options.class
@@ -169,6 +169,7 @@ module ZuoraConnect
         end
 
         self.build_task(task_data: mock_task_data, session: session)
+        self.set_backup_creds if !self['zuora_logins'].present?
         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
@@ -263,7 +264,7 @@ module ZuoraConnect
         end
 
         params = {
-          name: self.task_data.dig('name'), 
+          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
@@ -272,7 +273,7 @@ module ZuoraConnect
           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 }) 
+            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}
@@ -290,10 +291,7 @@ module ZuoraConnect
       elsif type == :user
         begin
           sql = <<-eos
-            SELECT zuora_users.zuora_identity_response 
-            FROM "#{self.id}".zuora_users 
-            ORDER BY zuora_users.updated_at DESC 
-            LIMIT 1;
+            SELECT zuora_users.zuora_identity_response FROM "#{self.id}".zuora_users ORDER BY zuora_users.updated_at DESC LIMIT 1;
           eos
           user = ActiveRecord::Base.connection.execute(sql).to_a.first
 
@@ -301,7 +299,10 @@ module ZuoraConnect
             zuora_identity_response = JSON.parse(user.fetch('zuora_identity_response', '{}'))
             self.user_timezone = zuora_identity_response.values.first&.dig('timeZone')
           else
-            Rails.logger.error('Cannot find any user to set the timezone', app_instance_id: self.id)
+            if (Redis.current.hget(TIMEZONE_LOG_RATE_LIMIT_KEY, self.id).to_i + TIMEZONE_LOG_PERIOD.to_i) <= Time.now.to_i
+              Rails.logger.error('Cannot find any user to set the timezone', app_instance_id: self.id)
+              Redis.current.hset(TIMEZONE_LOG_RATE_LIMIT_KEY, self.id, Time.now.to_i)
+            end
           end
         rescue => ex
           Rails.logger.error('There is an error while getting timezone users', ex)
@@ -345,12 +346,12 @@ module ZuoraConnect
       self.id >= 25000000
     end
 
-    def refresh(session: {}) 
+    def refresh(session: {})
       refresh_count ||= 0
       skip_connect ||= false
       begin
         #Check how app was deployed
-        if self.id < 25000000 && !skip_connect 
+        if !self.auto_deployed? && !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})
 
@@ -362,16 +363,8 @@ module ZuoraConnect
             end
 
             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        
+            self.set_backup_creds
+            self.save(validate: false) if self.changed?    
           else
             raise ZuoraConnect::Exceptions::ConnectCommunicationError.new("Error Communicating with Connect", response.body, response.code)
           end
@@ -416,8 +409,16 @@ module ZuoraConnect
     end
 
     #### START KMS ENCRYPTION Methods ####
+      def set_backup_creds
+        if self.kms_key.present? && self.kms_key.match(/^arn:aws:.*/) && self.task_data.present?
+          self.zuora_logins = self.strip_cache_data(object: self.task_data.dup, keys: ['applications', 'tokens', 'user_settings'])
+        end  
+      end 
+
       def zuora_logins=(val)
         write_attribute(:zuora_logins, kms_encrypt(val.to_json))
+      rescue Aws::KMS::Errors::ValidationException, Aws::KMS::Errors::NotFoundException, *AWS_AUTH_ERRORS => ex
+        Rails.logger.warn(AWS_AUTH_ERRORS_MSG, ex)
       end
 
       def zuora_logins
@@ -477,82 +478,6 @@ module ZuoraConnect
         end
         Thread.current[:appinstance] = self
       end
-
-      def self.write_to_telegraf(*args)
-        if ZuoraConnect.configuration.enable_metrics && !defined?(Prometheus)
-          @@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 = {}
-
-        if type == "versions"
-          @data = {
-            app_name: ZuoraConnect::Telegraf.app_name,
-            url: "dummy",
-            Version_Gem: ZuoraConnect::VERSION,
-            Version_Zuora: ZuoraAPI::VERSION ,
-            Version_Ruby: RUBY_VERSION,
-            Version_Rails: Rails.version,
-            hold: 1
-          }
-        elsif type == "stats"
-          begin
-            Resque.redis.ping
-            @resque = Resque.info
-            @data = {
-              app_name: ZuoraConnect::Telegraf.app_name,
-              url: "dummy",
-              Resque:{
-                Jobs_Finished: @resque[:processed] ,
-                Jobs_Failed: @resque[:failed],
-                Jobs_Pending: @resque[:pending],
-                Workers_Active: @resque[:working],
-                Workers_Total: @resque[:workers]
-              }
-            }
-          rescue
-          end
-        end
-        return @data
-      end
     #### END Task Methods ####
 
     #### START Task Methods ####
@@ -595,7 +520,7 @@ module ZuoraConnect
         end
       rescue ZuoraConnect::Exceptions::MissMatch => ex
         raise
-      rescue ZuoraConnect::Exceptions::InvalidCredentialSet => ex 
+      rescue ZuoraConnect::Exceptions::InvalidCredentialSet => ex
         raise
       rescue => ex
         ZuoraConnect.logger.error("Build Task Error", ex)
@@ -651,12 +576,12 @@ module ZuoraConnect
         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?
+          if self.auto_deployed? && parsed_json['organization'].present?
             login_cache = self.zuora_logins
             login_cache.delete('organization')
             self.zuora_logins = login_cache.merge({'organizations' => [parsed_json['organization']]})
@@ -676,7 +601,7 @@ module ZuoraConnect
             end
           end
           self.save(:validate => false)
-         
+
           return parsed_json
         end
       rescue *(ZuoraAPI::Login::CONNECTION_EXCEPTIONS + ZuoraAPI::Login::CONNECTION_READ_EXCEPTIONS) => ex
@@ -730,7 +655,7 @@ module ZuoraConnect
       end
 
       def refresh_oauth
-        refresh_oauth_count ||= 0        
+        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,
@@ -1104,7 +1029,7 @@ module ZuoraConnect
             catalog_container = catalog_container[object_id]
           end
 
-          return catalog_container
+          return catalog_container || {}
         end
 
         if defined?(Redis.current) && object_id.present? && object_id.class == String && object_id.present?
@@ -1366,7 +1291,7 @@ module ZuoraConnect
 
     def self.without_sticking
        if self.connection.respond_to?(:without_sticking)
-        self.connection.without_sticking do 
+        self.connection.without_sticking do
           yield
         end
       else

data/config/initializers/postgresql_adapter.rb

@@ -26,7 +26,7 @@ module ActiveRecord
           if oids
             query += "WHERE t.oid::integer IN (%s)" % oids.join(", ")
           else
-            query += initializer.query_conditions_for_initial_load(type_map)
+            query += initializer.query_conditions_for_initial_load
           end
 
           execute_and_clear(query, "SCHEMA", []) do |records|

data/config/initializers/prometheus.rb

@@ -49,10 +49,10 @@ if defined? Prometheus
     prometheus = Prometheus::Client.registry
 
     # Create your metrics.
-    ZUORA_VERSION = prometheus.gauge(:zuora_version, docstring: 'The current Zuora Gem version.', labels: %i(version name),  preset_labels: { version: ZuoraAPI::VERSION, name: ZuoraConnect::Telegraf.app_name }, store_settings: most_recent_aggregation)
-    CONNECT_VERSION = prometheus.gauge(:gem_version, docstring: 'The current Connect Gem version.', labels: %i(version name), preset_labels: { version: ZuoraConnect::VERSION, name: ZuoraConnect::Telegraf.app_name }, store_settings: most_recent_aggregation)
-    RAILS_VERSION = prometheus.gauge(:rails_version, docstring: 'The current Rails version.', labels: %i(version name), preset_labels: { version: Rails.version, name: ZuoraConnect::Telegraf.app_name }, store_settings: most_recent_aggregation)
-    RUBY_V = prometheus.gauge(:ruby_version, docstring: 'The current Ruby version.', labels: %i(version name), preset_labels: { version: RUBY_VERSION, name: ZuoraConnect::Telegraf.app_name }, store_settings: most_recent_aggregation)
+    ZUORA_VERSION = prometheus.gauge(:zuora_version, docstring: 'The current Zuora Gem version.', labels: %i(version name),  preset_labels: { version: ZuoraAPI::VERSION, name: ZuoraObservability::Env.app_name }, store_settings: most_recent_aggregation)
+    CONNECT_VERSION = prometheus.gauge(:gem_version, docstring: 'The current Connect Gem version.', labels: %i(version name), preset_labels: { version: ZuoraConnect::VERSION, name: ZuoraObservability::Env.app_name }, store_settings: most_recent_aggregation)
+    RAILS_VERSION = prometheus.gauge(:rails_version, docstring: 'The current Rails version.', labels: %i(version name), preset_labels: { version: Rails.version, name: ZuoraObservability::Env.app_name }, store_settings: most_recent_aggregation)
+    RUBY_V = prometheus.gauge(:ruby_version, docstring: 'The current Ruby version.', labels: %i(version name), preset_labels: { version: RUBY_VERSION, name: ZuoraObservability::Env.app_name }, store_settings: most_recent_aggregation)
 
     ZUORA_VERSION.set(0)
     CONNECT_VERSION.set(0)
@@ -61,12 +61,12 @@ if defined? Prometheus
 
     # Do they have resque jobs?
     if defined? Resque.redis
-      REDIS_CONNECTION = prometheus.gauge(:redis_connection, docstring: 'The status of the redis connection, 0 or 1', labels: %i(connection name), preset_labels: {connection:'redis', name: ZuoraConnect::Telegraf.app_name}, store_settings: most_recent_aggregation)
-      JOBS_FINISHED = prometheus.gauge(:jobs_finished, docstring: 'Done resque jobs', labels: %i(type name), preset_labels: {type:'resque', name: ZuoraConnect::Telegraf.app_name}, store_settings: most_recent_aggregation)
-      WORKERS_TOTAL = prometheus.gauge(:workers_total, docstring: 'Total resque workers', labels: %i(type name), preset_labels: {type:'resque', name: ZuoraConnect::Telegraf.app_name}, store_settings: most_recent_aggregation)
-      WORKERS_ACTIVE = prometheus.gauge(:workers_active, docstring: 'Active resque workers', labels: %i(type name), preset_labels: {type:'resque', name: ZuoraConnect::Telegraf.app_name}, store_settings: most_recent_aggregation)
-      JOBS_FAILED = prometheus.gauge(:jobs_failed, docstring: 'Failed resque jobs', labels: %i(type name), preset_labels: {type:'resque', name: ZuoraConnect::Telegraf.app_name}, store_settings: most_recent_aggregation)
-      JOBS_PENDING = prometheus.gauge(:jobs_pending, docstring: 'Pending resque jobs', labels: %i(type name), preset_labels: {type:'resque', name: ZuoraConnect::Telegraf.app_name}, store_settings: most_recent_aggregation)
+      REDIS_CONNECTION = prometheus.gauge(:redis_connection, docstring: 'The status of the redis connection, 0 or 1', labels: %i(connection name), preset_labels: {connection:'redis', name: ZuoraObservability::Env.app_name}, store_settings: most_recent_aggregation)
+      JOBS_FINISHED = prometheus.gauge(:jobs_finished, docstring: 'Done resque jobs', labels: %i(type name), preset_labels: {type:'resque', name: ZuoraObservability::Env.app_name}, store_settings: most_recent_aggregation)
+      WORKERS_TOTAL = prometheus.gauge(:workers_total, docstring: 'Total resque workers', labels: %i(type name), preset_labels: {type:'resque', name: ZuoraObservability::Env.app_name}, store_settings: most_recent_aggregation)
+      WORKERS_ACTIVE = prometheus.gauge(:workers_active, docstring: 'Active resque workers', labels: %i(type name), preset_labels: {type:'resque', name: ZuoraObservability::Env.app_name}, store_settings: most_recent_aggregation)
+      JOBS_FAILED = prometheus.gauge(:jobs_failed, docstring: 'Failed resque jobs', labels: %i(type name), preset_labels: {type:'resque', name: ZuoraObservability::Env.app_name}, store_settings: most_recent_aggregation)
+      JOBS_PENDING = prometheus.gauge(:jobs_pending, docstring: 'Pending resque jobs', labels: %i(type name), preset_labels: {type:'resque', name: ZuoraObservability::Env.app_name}, store_settings: most_recent_aggregation)
     end
 
     if defined?(Unicorn) && Unicorn.respond_to?(:listener_names)
@@ -74,17 +74,17 @@ if defined? Prometheus
         :unicorn_kills,
         docstring: 'Unicorn Kills',
         labels: %i(type name),
-        preset_labels: {type:'Unicorn-Killer', name: ZuoraConnect::Telegraf.app_name},
+        preset_labels: {type:'Unicorn-Killer', name: ZuoraObservability::Env.app_name},
         store_settings: sum_aggregation
       )
 
-      ZuoraConnect::AppInstanceBase.unicorn_listener_stats.each do |key, _|
+      ZuoraObservability::Metrics.unicorn_listener.each do |key, _|
         gauge_name = "unicorn_#{key}".gsub(/[^a-zA-Z0-9_]/, '_')
         gauge = prometheus.gauge(
           gauge_name.to_sym,
           docstring: 'Unicorn Stats',
           labels: %i(type name),
-          preset_labels: { type: 'unicorn', name: ZuoraConnect::Telegraf.app_name },
+          preset_labels: { type: 'unicorn', name: ZuoraObservability::Env.app_name },
           store_settings: most_recent_aggregation
         )
         Prometheus.const_set(

data/config/initializers/redis.rb

@@ -12,21 +12,21 @@ class RedisFlash
 end
 
 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 => "#{ZuoraObservability::Env.full_process_name(process_name: 'Redis')}", :url => redis_url, :timeout => 6, :reconnect_attempts => 2)
   browser_urls['Redis'] = { "url" => redis_url }
   if defined?(Resque.redis)
     if resque_url != redis_url
-      Resque.redis = Redis.new(:id => "#{ZuoraConnect::Telegraf.full_process_name(process_name: 'Resque')}", :url => resque_url, :timeout => 6, :reconnect_attempts => 2) 
+      Resque.redis = Redis.new(:id => "#{ZuoraObservability::Env.full_process_name(process_name: 'Resque')}", :url => resque_url, :timeout => 6, :reconnect_attempts => 2)
       browser_urls['Resque'] = { "url" => resque_url }
     else
       Resque.redis = Redis.current
     end
   end
   if defined?(flash_url.present?)
-    RedisFlash.current = Redis.new(:id => "#{ZuoraConnect::Telegraf.full_process_name(process_name: 'Flash')}", :url => flash_url, :timeout => 6, :reconnect_attempts => 2) 
+    RedisFlash.current = Redis.new(:id => "#{ZuoraObservability::Env.full_process_name(process_name: 'Flash')}", :url => flash_url, :timeout => 6, :reconnect_attempts => 2)
     browser_urls['Flash'] = { "url" => flash_url }
   end
 end
 if defined?(RedisBrowser)
   RedisBrowser.configure("connections" => browser_urls)
-end
+end

data/config/initializers/resque.rb

@@ -34,15 +34,3 @@ Resque.module_eval do
     Hash[queue_names.zip(sizes)]
   end
 end
-
-if defined?(Resque.logger)
-  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
-if defined?(Delayed::Worker.logger)
-  Delayed::Worker.logger = ZuoraConnect.custom_logger(name: "DelayedJob", type: 'Monologger', level: MonoLogger::INFO) 
-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)

data/config/initializers/unicorn.rb

@@ -6,7 +6,7 @@ if defined?(Unicorn::WorkerKiller)
       if defined?(Prometheus)
         Prometheus::UNICORN_KILLS.set(1)
       else
-        ZuoraConnect::AppInstance.write_to_telegraf(direction: 'Unicorn-Killer', tags: {app_instance: 0}, values: {kill: 1})
+        ZuoraObservability::Metrics.write_to_telegraf(direction: 'Unicorn-Killer', tags: {app_instance: 0}, values: {kill: 1})
       end
     end
   end
@@ -34,4 +34,4 @@ if defined?(Unicorn::HttpServer) && defined?(Prometheus)
   class Unicorn::Worker
     prepend WorkerExtensions
   end
-end
+end

data/config/routes.rb

@@ -1,6 +1,5 @@
 ZuoraConnect::Engine.routes.draw do
   get '/health' => 'static#health'
-  get '/internal/data' => 'static#metrics'
   post '/initialize_app' => 'static#initialize_app'
 
   if ENV['PROVISION_USER'].present? && ENV['PROVISION_SECRET'].present?

data/lib/metrics/net.rb

@@ -68,12 +68,12 @@ class HttpLogger
       log_request_body(request)
       log_request_headers(request)
       if defined?(response) && response
-        tags = tags.merge({status: response.code.to_i}) 
+        tags = tags.merge({status: response.code.to_i})
         log_response_code(response)
         log_response_headers(response)
         log_response_body(response.body)
       end
-      ZuoraConnect::AppInstance.write_to_telegraf(direction: :outbound, tags: tags, values: values)
+      ZuoraObservability::Metrics.write_to_telegraf(direction: :outbound, tags: tags, values: values)
     end
   end
 
@@ -95,7 +95,7 @@ class HttpLogger
   end
 
   HTTP_METHODS_WITH_BODY = Set.new(%w(POST PUT GET PATCH))
-  
+
   def log_request_body(request)
     if self.class.log_request_body
       if HTTP_METHODS_WITH_BODY.include?(request.method)
@@ -149,8 +149,8 @@ class HttpLogger
   def truncate_body(body)
     if collapse_body_limit && collapse_body_limit > 0 && body && body.size >= collapse_body_limit
       body_piece_size = collapse_body_limit / 2
-      body[0..body_piece_size] + 
-        "\n\n<some data truncated>\n\n" + 
+      body[0..body_piece_size] +
+        "\n\n<some data truncated>\n\n" +
         body[(body.size - body_piece_size)..body.size]
     else
       body
@@ -203,7 +203,7 @@ class Net::HTTP
 
   def request(request, body = nil, &block)
     HttpLogger.perform(self, request, body) do
-      request_without_logging(request, body, &block) 
+      request_without_logging(request, body, &block)
     end
   end
 end
@@ -215,4 +215,4 @@ if defined?(Rails)
       HttpLogger.logger = ZuoraConnect.logger unless HttpLogger.logger
     end
   end
-end
+end