zuora_connect 2.0.60l → 2.0.60

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 00f68595c6354e9924c2e73bdb81246bdc858874f49830f94111e0d46b6e8298
-  data.tar.gz: 1b01b3c05190970c9ad92c461f64b89787b790f3e2ffb6394831ccce425e0d1a
+  metadata.gz: bae96287832facbb0f512eedca7038f2bd566650d4e057f0d623613cb3acb559
+  data.tar.gz: d3b1f756842c3231a23719669d81c7aa206dfc677ae19ae2e537d3c3f6c089ae
 SHA512:
-  metadata.gz: e58fc8cd5b36a2be218afab342507a78acb5221001cdc712e61a7e80ad0615797ed42c7ae413d4d5dc179d14784e91eb621ea5be9466a45e904ed97bd5996076
-  data.tar.gz: df3730519a5b2b1e8b3778866bd6ac59255633666522fe7ec8522e6815a1c87d5aba89fd733ec1eaecf6caeccf74fde010ea40a9d882b20d6fe2cfc4f1ee46a2
+  metadata.gz: 872a07f80dfbe1c12428cacc4369fe83a0f59eb20d953c0c43f609d19cd75556138e1162f4e175c6fdf10844f4bf2a01c0f8f1529c7a6e0774d7b53b47f4e68a
+  data.tar.gz: c2f5653b77bbc93521c37062542d12697fb21e055cff18a55846837e6f454dd2ce15963580f6623e523d6b30f677bce8e1fb7820a28b981cfa69c73bd6f7333a

data/app/controllers/zuora_connect/static_controller.rb

@@ -1,11 +1,10 @@
 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]
-
-    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]
+    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 metrics
       type = params[:type].present? ? params[:type] : "versions"
@@ -14,11 +13,11 @@ module ZuoraConnect
 
     def health
       if params[:error].present?
-        begin
+        begin 
           raise ZuoraConnect::Exceptions::Error.new('This is an error')
         rescue => ex
           case params[:error]
-          when 'Log'
+          when 'Log'  
             Rails.logger.error("Error in Health", ex)
           when 'Exception'
             raise
@@ -35,13 +34,11 @@ module ZuoraConnect
     def initialize_app
       begin
         authenticate_connect_app_request
-        unless performed?
-          @appinstance.new_session(:session => @appinstance.data_lookup(:session => session))
-          render json: {
-            message: 'Success',
-            status: 200
-          }, status: 200
-        end
+        @appinstance.new_session(:session => @appinstance.data_lookup(:session => session))
+        render json: {
+          message: "Success",
+          status: 200
+        }, status: 200
       rescue => ex
         Rails.logger.error("Failed to Initialize application", ex)
         if performed?
@@ -55,74 +52,6 @@ module ZuoraConnect
       end
     end
 
-    def provision
-      create_new_instance
-      unless performed?
-        render json: {
-          status: 200,
-          message: 'Success',
-          app_instance_id: @appinstance.id
-        }, status: 200
-      end
-    rescue StandardError => e
-      message = 'Failed to provision new instance'
-      if performed?
-        Rails.logger.error("#{message}: #{performed?}", e)
-      else
-        Rails.logger.error(message, e)
-        render json: {
-          status: 500,
-          message: message
-        }, status: 500
-      end
-    end
-
-    def instance_user
-      ZuoraConnect::AppInstance.read_master_db do
-        ZuoraConnect.logger.with_fields = {} if ZuoraConnect.logger.is_a?(Ougai::Logger)
-        Rails.logger.with_fields = {} if Rails.logger.is_a?(Ougai::Logger)
-
-        if defined?(ElasticAPM) && ElasticAPM.running? && ElasticAPM.respond_to?(:set_label)
-          ElasticAPM.set_label(:trace_id, request.uuid)
-        end
-
-        unless params[:id].present?
-          render json: {
-            status: 400,
-            message: 'No app instance id provided'
-          }, status: :bad_request
-          return
-        end
-
-        @appinstance = ZuoraConnect::AppInstance.find(params[:id]).new_session
-      end
-
-      zuora_client = @appinstance.send(ZuoraConnect::AppInstance::LOGIN_TENANT_DESTINATION).client
-      client_describe, = zuora_client.rest_call(
-        url: zuora_client.rest_endpoint('genesis/user/info').gsub('v1/', ''),
-        session_type: zuora_client.class == ZuoraAPI::Oauth ? :bearer : :basic
-      )
-
-      render json: {
-        status: 200,
-        message: 'Success',
-        user_id: client_describe['coreUserId'],
-        username: client_describe['username'],
-        email: client_describe['workEmail']
-      }, status: 200
-    rescue ActiveRecord::RecordNotFound
-      render json: {
-        status: 400,
-        message: 'No app instance found'
-      }, status: :bad_request
-    rescue StandardError => e
-      Rails.logger.error('Error occurred getting user details', e)
-      render json: {
-        status: 500,
-        message: 'Failed to get user details'
-      }, status: 500
-    end
-
     private
 
     def clear_connect_app_session

data/app/models/zuora_connect/app_instance_base.rb

@@ -11,7 +11,7 @@ module ZuoraConnect
     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, :user_timezone
+    attr_accessor :options, :mode, :logins, :task_data, :last_refresh, :username, :password, :s3_client, :api_version, :drop_message, :new_session_message, :connect_user, :logitems
     @@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
@@ -240,50 +240,7 @@ module ZuoraConnect
       rescue I18n::InvalidLocale => ex
         ZuoraConnect.logger.error(ex) if !IGNORED_LOCALS.include?(ex.locale.to_s.downcase)
       end
-
-      begin
-        sql = <<-eos
-          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
-
-        if user.present?
-          zuora_identity_response = JSON.parse(user.fetch('zuora_identity_response', '{}'))
-          self.user_timezone = zuora_identity_response.values.first&.dig('timeZone')
-        end
-      rescue => ex
-        Rails.logger.error('Failed to get users while setting app instance timezone', ex)
-      end
-
-      if self.user_timezone.present?
-        # connect instance which has a custom timezone
-        if !self.auto_deployed? && (
-          ActiveSupport::TimeZone[self.task_data.dig('user_settings', 'timezone') || '']&.utc_offset !=
-            ActiveSupport::TimeZone[self.user_timezone]&.utc_offset
-        )
-          if self.environment == 'Production'
-            ZuoraConnect.logger.error(
-              "Instance and user timezones are different. User has '#{self.user_timezone}' and " \
-              "instance has '#{self.task_data.dig('user_settings', 'timezone')}'",
-              app_instance_id: self.id
-            )
-          end
-          self.user_timezone = nil
-          Time.zone = self.timezone
-        else
-          begin
-            Time.zone = self.user_timezone
-          rescue ArgumentError
-            Time.zone = self.timezone
-          end
-        end
-      else
-        Time.zone = self.timezone
-      end
-
+      Time.zone = self.timezone
       if self.task_data.present?
         tenants = self.task_data.fetch('tenant_ids', [])
         organizations = self.task_data.fetch('organizations', [])
@@ -315,10 +272,6 @@ module ZuoraConnect
       end
     end
 
-    def auto_deployed?
-      self.id >= 25000000
-    end
-
     def refresh(session: {}) 
       refresh_count ||= 0
       skip_connect ||= false
@@ -385,10 +338,6 @@ module ZuoraConnect
       raise
     end
 
-    def aws_secrets
-      (Rails.application.secrets.aws || {}).transform_keys { |key| key.to_s }
-    end
-
     #### START KMS ENCRYPTION Methods ####
       def zuora_logins=(val)
         write_attribute(:zuora_logins, kms_encrypt(val.to_json))
@@ -401,7 +350,7 @@ module ZuoraConnect
 
       def kms_decrypt(value)
         kms_tries ||= 0
-        kms_client = Aws::KMS::Client.new({region: aws_secrets['AWS_REGION'], credentials: self.aws_auth_client}.delete_if { |k, v| v.blank? })
+        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
@@ -416,7 +365,7 @@ module ZuoraConnect
 
       def kms_encrypt(value)
         kms_tries ||= 0
-        kms_client = Aws::KMS::Client.new({region: aws_secrets['AWS_REGION'], credentials: self.aws_auth_client}.delete_if {|k,v| v.blank? })
+        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
@@ -431,12 +380,12 @@ module ZuoraConnect
       end
 
       def kms_key
-        return ENV['AWS_KMS_ARN'] || aws_secrets['AWS_KMS_ARN']
+        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(aws_secrets['AWS_ACCESS_KEY_ID'], aws_secrets['AWS_SECRET_ACCESS_KEY'])
+          return Aws::Credentials.new(Rails.application.secrets.aws['AWS_ACCESS_KEY_ID'], Rails.application.secrets.aws['AWS_SECRET_ACCESS_KEY'])
         else
           return nil
         end
@@ -453,7 +402,7 @@ module ZuoraConnect
       end
 
       def self.write_to_telegraf(*args)
-        if ZuoraConnect.configuration.enable_metrics && !defined?(Prometheus)
+        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?

data/config/initializers/postgresql_adapter.rb

@@ -1,15 +1,9 @@
 module ActiveRecord
   module ConnectionAdapters
     class PostgreSQLAdapter < AbstractAdapter
-
-      SCHEMA_ADDITIONAL_TYPES = 'SchemaAdditionalTypes'.freeze
-
       private
-        def load_additional_types_latest(oids = nil)
+        def load_additional_types(type_map, oids = nil)
           initializer = OID::TypeMapInitializer.new(type_map)
-
-          return if loaded_from_cache?(initializer)
-
           if supports_ranges?
             query = <<-SQL
               SELECT DISTINCT on (t.typname) t.oid, t.typname, t.typelem, t.typdelim, t.typinput, r.rngsubtype, t.typtype, t.typbasetype
@@ -30,73 +24,9 @@ module ActiveRecord
           end
 
           execute_and_clear(query, "SCHEMA", []) do |records|
-            cache_additional_types(records)
             initializer.run(records)
           end
         end
-
-        def load_additional_types_deprecated(type_map, oids = nil)
-          initializer = OID::TypeMapInitializer.new(type_map)
-
-          return if loaded_from_cache?(initializer)
-
-          if supports_ranges?
-            query = <<-SQL
-              SELECT DISTINCT on (t.typname) t.oid, t.typname, t.typelem, t.typdelim, t.typinput, r.rngsubtype, t.typtype, t.typbasetype
-              FROM pg_type as t
-              LEFT JOIN pg_range as r ON oid = rngtypid
-            SQL
-          else
-            query = <<-SQL
-              SELECT DISTINCT on (t.typname) t.oid, t.typname, t.typelem, t.typdelim, t.typinput, t.typtype, t.typbasetype
-              FROM pg_type as t
-            SQL
-          end
-
-          if oids
-            query += "WHERE t.oid::integer IN (%s)" % oids.join(", ")
-          else
-            query += initializer.query_conditions_for_initial_load(type_map)
-          end
-
-          execute_and_clear(query, "SCHEMA", []) do |records|
-            cache_additional_types(records)
-            initializer.run(records)
-          end
-        end
-
-        def loaded_from_cache?(initializer)
-          if defined?(Redis.current)
-            begin
-              if Redis.current.exists(SCHEMA_ADDITIONAL_TYPES)
-                initializer.run(JSON.parse(Redis.current.get(SCHEMA_ADDITIONAL_TYPES)))
-                return true
-              end
-            rescue => ex
-              Rails.logger.warn('Exception occurred while loading additional types', ex)
-            end
-          end
-
-          false
-        end
-
-        def cache_additional_types(records)
-          if defined?(Redis.current)
-            begin
-              Redis.current.setex(SCHEMA_ADDITIONAL_TYPES, 1.hour.to_i, records.to_json)
-            rescue => ex
-              Rails.logger.warn('Exception occurred while caching additional types', ex)
-            end
-          end
-        end
-
-
-        rails_version = Rails.version.split('.').map { |x| x.to_i }
-        if (rails_version <=> [5, 2, 0]) >= 1
-          alias :load_additional_types :load_additional_types_latest
-        else
-          alias :load_additional_types :load_additional_types_deprecated
-        end
     end
   end
 end

data/config/initializers/prometheus.rb

@@ -3,93 +3,38 @@ if defined? Prometheus
     require "zuora_connect/version"
     require "zuora_api/version"
 
-    resque_path = "#{ENV['RESQUE_EXPORTER_PATH'] || Rails.root.join('tmp/resque_exporter')}/*.prom"
-    prometheus_path = Rails.root.join("tmp/prometheus")
-
-    Dir[resque_path, "#{prometheus_path}/*.bin"].each do |file_path|
-      File.unlink(file_path)
-    end
-
-    require 'prometheus/client/data_stores/direct_file_store'
-    Prometheus::Client.config.data_store = Prometheus::Client::DataStores::DirectFileStore.new(
-      dir: prometheus_path
-    )
-
-    class ResqueExporter
-      require 'prometheus/client/formats/text'
-      require 'fileutils'
-
-      def initialize
-        @lock = Monitor.new
-        @registry = Prometheus::Client.registry
-        @path = ENV['RESQUE_EXPORTER_PATH'] || Rails.root.join('tmp/resque_exporter')
-        FileUtils.mkdir_p(@path)
-      end
-
-      def export
-        filename = File.join(@path, 'resque_export.prom')
-        @lock.synchronize do
-          File.open(filename, 'w+') do |file|
-            file.write(Prometheus::Client::Formats::Text.marshal(@registry))
-          end
-        end
-      end
-    end
-
-    most_recent_aggregation = {}
-    sum_aggregation = {}
-    if defined?(Unicorn)
-      most_recent_aggregation[:aggregation] = :most_recent
-      sum_aggregation[:aggregation] = :sum
-    end
-
     # Create a default Prometheus registry for our metrics.
     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::Client::Gauge.new(:zuora_version, 'The current Zuora Gem version.')
+    CONNECT_VERSION = Prometheus::Client::Gauge.new(:gem_version, 'The current Connect Gem version.')
+    RAILS_VERSION = Prometheus::Client::Gauge.new(:rails_version, 'The current Rails version.')
+    RUBY_V = Prometheus::Client::Gauge.new(:ruby_version, 'The current Ruby version.')
 
-    ZUORA_VERSION.set(0)
-    CONNECT_VERSION.set(0)
-    RAILS_VERSION.set(0)
-    RUBY_V.set(0)
+    # Register your metrics with the registry we previously created.
+    prometheus.register(ZUORA_VERSION);ZUORA_VERSION.set({version: ZuoraAPI::VERSION, name: ZuoraConnect::Telegraf.app_name},0)
+    prometheus.register(CONNECT_VERSION);CONNECT_VERSION.set({version: ZuoraConnect::VERSION, name: ZuoraConnect::Telegraf.app_name},0)
+    prometheus.register(RAILS_VERSION);RAILS_VERSION.set({version: Rails.version, name: ZuoraConnect::Telegraf.app_name},0)
+    prometheus.register(RUBY_V);RUBY_V.set({version: RUBY_VERSION, name: ZuoraConnect::Telegraf.app_name},0)
 
     # 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)
-    end
-
-    if defined?(Unicorn) && Unicorn.respond_to?(:listener_names)
-      UNICORN_KILLS = prometheus.gauge(
-        :unicorn_kills,
-        docstring: 'Unicorn Kills',
-        labels: %i(type name),
-        preset_labels: {type:'Unicorn-Killer', name: ZuoraConnect::Telegraf.app_name},
-        store_settings: sum_aggregation
-      )
+      REDIS_CONNECTION = Prometheus::Client::Gauge.new(:redis_connection, 'The status of the redis connection, 0 or 1')
+      FINISHED_JOBS = Prometheus::Client::Gauge.new(:finished_jobs, 'Done resque jobs')
+      WORKERS = Prometheus::Client::Gauge.new(:workers, 'Total resque workers')
+      ACTIVE_WORKERS = Prometheus::Client::Gauge.new(:active_workers, 'Active resque workers')
+      FAILED_JOBS = Prometheus::Client::Gauge.new(:failed_jobs, 'Failed resque jobs')
+      PENDING_JOBS = Prometheus::Client::Gauge.new(:pending_jobs, 'Pending resque jobs')
+
+      prometheus.register(REDIS_CONNECTION)
+      prometheus.register(FINISHED_JOBS)
+      prometheus.register(ACTIVE_WORKERS)
+      prometheus.register(WORKERS)
+      prometheus.register(FAILED_JOBS)
+      prometheus.register(PENDING_JOBS)
 
-      ZuoraConnect::AppInstanceBase.unicorn_listener_stats.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 },
-          store_settings: most_recent_aggregation
-        )
-        Prometheus.const_set(
-          gauge_name.upcase,
-          gauge
-        )
-      end
     end
+
   end
 end

data/config/initializers/resque.rb

@@ -5,20 +5,6 @@ if defined?(Resque::Worker)
   Resque::Job.send(:include, Resque::SelfLookup)
 end
 
-if defined?(Resque::Job) && defined?(Prometheus)
-  module ResquePrometheusExtensions
-    EXPORTER = Prometheus::ResqueExporter.new
-    def perform
-      super
-      EXPORTER.export
-    end
-  end
-
-  class Resque::Job
-    prepend ResquePrometheusExtensions
-  end
-end
-
 Resque.module_eval do
   # Returns a hash, mapping queue names to queue sizes
   def queue_sizes

data/config/initializers/unicorn.rb

@@ -3,35 +3,7 @@ if defined?(Unicorn::WorkerKiller)
     self.singleton_class.send(:alias_method, :kill_self_old, :kill_self)
     def self.kill_self(logger, start_time)
       self.kill_self_old(logger, start_time)
-      if defined?(Prometheus)
-        Prometheus::UNICORN_KILLS.set(1)
-      else
-        ZuoraConnect::AppInstance.write_to_telegraf(direction: 'Unicorn-Killer', tags: {app_instance: 0}, values: {kill: 1})
-      end
+      ZuoraConnect::AppInstance.write_to_telegraf(direction: 'Unicorn-Killer', tags: {app_instance: 0}, values: {kill: 1})
     end
   end
-end
-
-if defined?(Unicorn::HttpServer) && defined?(Prometheus)
-  module HttpServerExtensions
-    def kill_worker(signal, wpid)
-      Prometheus::UNICORN_KILLS.increment
-      super
-    end
-  end
-
-  module WorkerExtensions
-    def soft_kill(sig)
-      Prometheus::UNICORN_KILLS.increment
-      super
-    end
-  end
-
-  class Unicorn::HttpServer
-    prepend HttpServerExtensions
-  end
-
-  class Unicorn::Worker
-    prepend WorkerExtensions
-  end
 end

data/config/routes.rb

@@ -3,11 +3,6 @@ ZuoraConnect::Engine.routes.draw do
   get '/internal/data' => 'static#metrics'
   post '/initialize_app' => 'static#initialize_app'
 
-  if ENV['PROVISION_USER'].present? && ENV['PROVISION_SECRET'].present?
-    post '/provision' => 'static#provision'
-    get '/instance/:id/user' => 'static#instance_user'
-  end
-
   namespace :api do
     namespace :v1 do
       resources :app_instance, :only => [:index], defaults: {format: :json} do

data/lib/middleware/json_parse_errors.rb

@@ -7,7 +7,7 @@ module ZuoraConnect
     def call(env)
       begin
         @app.call(env)
-      rescue DynamicRailsError => error
+      rescue ActionDispatch::ParamsParser::ParseError => error
         if env['HTTP_ACCEPT'] =~ /application\/json/ || env['CONTENT_TYPE'] =~ /application\/json/
           return [
             400, { "Content-Type" => "application/json" },
@@ -18,16 +18,5 @@ module ZuoraConnect
         end
       end
     end
-
-    # Note(hartley): remove once the minimum supported version of Rails is 5.2
-    class DynamicRailsError < StandardError
-      def self.===(exception)
-        if Rails.version >= "5.2"
-          exception.is_a?(ActionDispatch::Http::Parameters::ParseError)
-        else
-          exception.is_a?(ActionDispatch::ParamsParser::ParseError)
-        end
-      end
-    end
   end
-end
+end

data/lib/middleware/metrics_middleware.rb

@@ -64,22 +64,6 @@ module ZuoraConnect
         #Remove bad headers
         @bad_headers.each { |header| env.delete(header) }
 
-        if defined?(Prometheus) && env['PATH_INFO'] == '/connect/internal/metrics'
-          # Prometheus Stuff
-          metrics = ZuoraConnect::AppInstance.get_metrics('stats')
-          redis_up = metrics.present? && metrics.dig(:Resque, :Workers_Total).present? ? 1 : 0
-          Prometheus::REDIS_CONNECTION.set(redis_up)
-
-          process_prometheus_metric(metrics: metrics)
-
-          if defined?(Unicorn) && Unicorn.respond_to?(:listener_names)
-            ZuoraConnect::AppInstanceBase.unicorn_listener_stats.each do |key, value|
-              gauge = Prometheus.const_get("unicorn_#{key}".gsub(/[^a-zA-Z0-9_]/, '_').upcase)
-              gauge.set(value) if gauge.present?
-            end
-          end
-        end
-
         #Thread.current[:appinstance] = nil
         start_time = Time.now
         begin
@@ -93,6 +77,35 @@ module ZuoraConnect
             ZuoraConnect::AppInstanceBase.write_to_telegraf(direction: 'request-inbound-assets', tags: tags, values: values)
           end
 
+          if defined? Prometheus
+            #Prometheus Stuff
+            if env['PATH_INFO'] == '/connect/internal/metrics'
+
+              #Do something before each scrape
+              if defined? Resque.redis
+                begin
+
+                  Resque.redis.ping
+
+                  Prometheus::REDIS_CONNECTION.set({connection:'redis',name: ZuoraConnect::Telegraf.app_name},1)
+                  Prometheus::FINISHED_JOBS.set({type:'resque',name: ZuoraConnect::Telegraf.app_name},Resque.info[:processed])
+                  Prometheus::PENDING_JOBS.set({type:'resque',name: ZuoraConnect::Telegraf.app_name},Resque.info[:pending])
+                  Prometheus::ACTIVE_WORKERS.set({type:'resque',name: ZuoraConnect::Telegraf.app_name},Resque.info[:working])
+                  Prometheus::WORKERS.set({type:'resque',name: ZuoraConnect::Telegraf.app_name},Resque.info[:workers])
+                  Prometheus::FAILED_JOBS.set({type:'resque',name: ZuoraConnect::Telegraf.app_name},Resque.info[:failed])
+
+                rescue Redis::CannotConnectError
+                    Prometheus::REDIS_CONNECTION.set({connection:'redis',name: ZuoraConnect::Telegraf.app_name},0)
+                end
+
+                if ZuoraConnect.configuration.custom_prometheus_update_block != nil
+                  ZuoraConnect.configuration.custom_prometheus_update_block.call()
+                end
+              end
+
+            end
+          end
+
           # Uncomment following block of code for handling engine requests/requests without controller
           # else
           #   # Handling requests which do not have controllers (engines)
@@ -106,10 +119,10 @@ module ZuoraConnect
               content_type = @headers['Content-Type'].split(';')[0] if @headers['Content-Type']
               content_type = content_type.gsub('text/javascript', 'application/javascript')
               tags = {status: @status, content_type: content_type}
-
+           
               tags = tags.merge({controller: 'ActionController'})
               tags = tags.merge({action: 'RoutingError' }) if @status == 404
-
+              
               values = {response_time: ((Time.now - start_time)*1000).round(2) }
 
               ZuoraConnect::AppInstanceBase.write_to_telegraf(direction: :inbound, tags: tags, values: values)
@@ -120,32 +133,5 @@ module ZuoraConnect
         [@status, @headers, @response]
       end
     end
-
-    def process_prometheus_metric(type: 'none', metrics: {})
-      return if metrics.blank?
-
-      prometheus = Prometheus::Client.registry
-      most_recent_aggregation = {}
-      if Prometheus::Client.config.data_store.is_a?(Prometheus::Client::DataStores::DirectFileStore)
-        most_recent_aggregation[:aggregation] = :most_recent
-      end
-      metrics.each do |key, value|
-        next if %w[app_name url].include?(key.to_s)
-
-        if value.is_a?(Hash)
-          process_prometheus_metric(type: key.to_s, metrics: value)
-        else
-          gauge_name = key.to_s.downcase.gsub(/[^a-z0-9_]/, '_')
-          gauge = prometheus.get(gauge_name.to_sym) || prometheus.gauge(
-            gauge_name.to_sym,
-            docstring: "#{key} metric",
-            labels: %i(type name),
-            preset_labels: { type: type, name: ZuoraConnect::Telegraf.app_name },
-            store_settings: most_recent_aggregation
-          )
-          gauge.set(value)
-        end
-      end
-    end
   end
 end

data/lib/resque/dynamic_queues.rb

@@ -92,7 +92,7 @@ module Resque
         log_with_severity :error, "Error reserving job: #{ex.inspect}"
         log_with_severity :error, ex.backtrace.join("\n")
       end
-      raise ex
+      raise e
     end
 
     def create_job(queue, payload)

data/lib/zuora_connect/controllers/helpers.rb

@@ -124,24 +124,14 @@ module ZuoraConnect
             ElasticAPM.set_user(session["#{@appinstance.id}::user::email"])  if defined?(ElasticAPM) && ElasticAPM.running?
             PaperTrail.whodunnit =  session["#{@appinstance.id}::user::email"] if defined?(PaperTrail)
           end
-
-          locale = (session["#{@appinstance.id}::user::locale"] || "").gsub("_", "-") 
           begin
+            locale = session["#{@appinstance.id}::user::locale"]
             I18n.locale = locale.present? ? locale : @appinstance.locale
           rescue I18n::InvalidLocale => ex
-            if locale.include?("-")
-              locale = locale.split("-").first
-              retry
-            elsif locale != session["#{@appinstance.id}::user::language"]
-              locale = session["#{@appinstance.id}::user::language"]
-              retry
-            end
             ZuoraConnect.logger.error(ex) if !ZuoraConnect::AppInstance::IGNORED_LOCALS.include?(ex.locale.to_s.downcase)
           end
           begin
-            if @appinstance.user_timezone.blank?
-              Time.zone = session["#{@appinstance.id}::user::timezone"] ? session["#{@appinstance.id}::user::timezone"] : @appinstance.timezone
-            end
+            Time.zone = session["#{@appinstance.id}::user::timezone"] ? session["#{@appinstance.id}::user::timezone"] : @appinstance.timezone
           rescue
             ZuoraConnect.logger.error(ex)
           end
@@ -229,80 +219,6 @@ module ZuoraConnect
         return (request.headers['ZuoraCurrentEntity'].present? || cookies['ZuoraCurrentEntity'].present?)
       end
 
-      def create_new_instance
-        ZuoraConnect::AppInstance.read_master_db do
-          Thread.current[:appinstance] = nil
-          ZuoraConnect.logger.with_fields = {} if ZuoraConnect.logger.is_a?(Ougai::Logger)
-          Rails.logger.with_fields = {} if Rails.logger.is_a?(Ougai::Logger)
-
-          if defined?(ElasticAPM) && ElasticAPM.running? && ElasticAPM.respond_to?(:set_label)
-            ElasticAPM.set_label(:trace_id, request.uuid)
-          end
-
-          zuora_host = request.headers['zuora-host']
-          zuora_entity_id = (request.headers['zuora-entity-ids'] || '').gsub(
-            '-',
-            ''
-          ).split(',').first
-
-          # Validate host present
-          if zuora_host.blank?
-            render json: {
-              status: 401,
-              message: 'zuora-host header was not supplied.'
-            }, status: :unauthorized
-            return
-          end
-
-          # Validate entity-ids present
-          if zuora_entity_id.blank?
-            render json: {
-              status: 401,
-              message: 'zuora-entity-ids header was not supplied.'
-            }, status: :unauthorized
-            return
-          end
-
-          rest_domain = ZuoraAPI::Login.new(url: "https://#{zuora_host}").rest_domain
-          app_instance_id = ZuoraConnect::AppInstance.where(
-            'zuora_entity_ids ?& array[:entities] AND zuora_domain = :host',
-            entities: [zuora_entity_id],
-            host: rest_domain
-          ).pluck(:id).first
-
-          if app_instance_id.present?
-            render json: {
-              status: 409,
-              message: 'Instance already exists.',
-              app_instance_id: app_instance_id
-            }, status: 409
-          else
-            Apartment::Tenant.switch!("public")
-            retry_count = 3
-            begin
-              @appinstance = new_instance(
-                next_instance_id,
-                zuora_entity_id,
-                rest_domain,
-                retry_count: retry_count
-              )
-            rescue ActiveRecord::RecordNotUnique
-              retry if (retry_count -= 1).positive?
-              return
-            end
-
-            app_instance_id = @appinstance.id
-          end
-
-          begin
-            Apartment::Tenant.switch!('public')
-            Apartment::Tenant.create(app_instance_id.to_s)
-          rescue Apartment::TenantExists
-            ZuoraConnect.logger.debug('Tenant Already Exists')
-          end
-        end
-      end
-
     private
       def setup_instance_via_prod_mode
         zuora_entity_id = request.headers['ZuoraCurrentEntity'] || cookies['ZuoraCurrentEntity']
@@ -310,7 +226,7 @@ module ZuoraConnect
         if zuora_entity_id.present?
           zuora_tenant_id = cookies['Zuora-Tenant-Id']
           zuora_user_id = cookies['Zuora-User-Id']
-          zuora_host = request.headers['HTTP_X_FORWARDED_HOST'] || request.headers['Zuora-Host'] || 'apisandbox.zuora.com'
+          zuora_host = request.headers["HTTP_X_FORWARDED_HOST"] || "apisandbox.zuora.com"
 
           zuora_details = {'host' => zuora_host, 'user_id' => zuora_user_id, 'tenant_id' => zuora_tenant_id, 'entity_id' => zuora_entity_id}
           auth_headers = {}
@@ -412,16 +328,13 @@ module ZuoraConnect
 
             zuora_user_id = cookies['Zuora-User-Id'] || session["ZuoraCurrentIdentity"]['userId']
 
+            #One deployed instance
             if appinstances.size == 1
               ZuoraConnect.logger.debug("Instance is #{appinstances.to_h.keys.first}")
               @appinstance = ZuoraConnect::AppInstance.find(appinstances.to_h.keys.first)
-            end
 
-            # One deployed instance with credentials
-            if defined?(@appinstance) && !@appinstance['zuora_logins'].nil?
               #Add user/update
               begin
-                ZuoraConnect::ZuoraUser.reset_table_name
                 @zuora_user = ZuoraConnect::ZuoraUser.where(:zuora_user_id => zuora_user_id).first
               rescue ActiveRecord::StatementInvalid => ex
                 if ex.message.include?("PG::UndefinedTable") && ex.message.include?("zuora_users")
@@ -445,8 +358,7 @@ module ZuoraConnect
               session["#{@appinstance.id}::user::localUserId"] = @zuora_user.id
               session["#{@appinstance.id}::user::email"] = session['ZuoraCurrentIdentity']["username"]
               session["#{@appinstance.id}::user::timezone"] = session['ZuoraCurrentIdentity']["timeZone"]
-              session["#{@appinstance.id}::user::language"] = session['ZuoraCurrentIdentity']["language"]
-              session["#{@appinstance.id}::user::locale"] = session['ZuoraCurrentIdentity']["locale"]
+              session["#{@appinstance.id}::user::locale"] = session['ZuoraCurrentIdentity']["language"]
               session["appInstance"] = @appinstance.id
 
             #We have multiple, user must pick
@@ -468,85 +380,79 @@ module ZuoraConnect
                 return
               end
               Apartment::Tenant.switch!("public")
-              retry_count = 3
-              task_data = {}
-              begin
-                ActiveRecord::Base.transaction do
-                  ActiveRecord::Base.connection.execute('LOCK public.zuora_users IN ACCESS EXCLUSIVE MODE')
+              ActiveRecord::Base.transaction do
+                ActiveRecord::Base.connection.execute('LOCK public.zuora_users IN ACCESS EXCLUSIVE MODE')
+                appinstances = ZuoraConnect::AppInstance.where("zuora_entity_ids ?& array[:entities] = true AND zuora_domain = :host", entities: [zuora_entity_id], host: zuora_client.rest_domain).pluck(:id, :name)
 
-                  unless defined?(@appinstance)
-                    appinstances = ZuoraConnect::AppInstance.where("zuora_entity_ids ?& array[:entities] = true AND zuora_domain = :host", entities: [zuora_entity_id], host: zuora_client.rest_domain).pluck(:id, :name)
-
-                    if appinstances.size > 0
-                      redirect_to "https://#{zuora_host}/apps/newlogin.do?retURL=#{request.fullpath}"
-                      return
-                    end
-                  end
+                if appinstances.size > 0
+                  redirect_to "https://#{zuora_host}/apps/newlogin.do?retURL=#{request.fullpath}"
+                  return
+                end
 
-                  next_id = defined?(@appinstance) ? @appinstance.id : next_instance_id
-                  if task_data.blank?
-                    user = (ENV['DEIS_APP'] || "Application").split('-').map(&:capitalize).join(' ')
-                    body = {
-                      'userId' => zuora_user_id,
-                      'entityIds' => [zuora_entity_id.unpack("a8a4a4a4a12").join('-')],
-                      'customAuthorities' => [],
-                      'additionalInformation' => {
-                        'description' => "This user is for #{user} application.",
-                        'name' => "#{user} API User #{next_id}"
-                      }
-                    }
-
-                    oauth_response, response = zuora_client.rest_call(
-                      method: :post,
-                      body: body.to_json,
-                      url: zuora_client.rest_endpoint("genesis/clients").gsub('v1/', ''),
-                      session_type: zuora_client.class == ZuoraAPI::Oauth ? :bearer : :basic,
-                      headers: auth_headers
-                    )
-
-                    new_zuora_client = ZuoraAPI::Oauth.new(url: "https://#{zuora_host}", oauth_client_id: oauth_response["clientId"], oauth_secret: oauth_response["clientSecret"] )
-                    if session["ZuoraCurrentUserInfo"].blank?
-                      client_describe, response = new_zuora_client.rest_call(url: zuora_client.rest_endpoint("genesis/user/info").gsub('v1/', ''), session_type: :bearer)
-                    else
-                      client_describe = session["ZuoraCurrentUserInfo"]
-                    end
+                next_id = (ZuoraConnect::AppInstance.all.where('id > 24999999').order(id: :desc).limit(1).pluck(:id).first || 24999999) + 1
+                user = (ENV['DEIS_APP'] || "Application").split('-').map(&:capitalize).join(' ')
+                body = {
+                  'userId' => zuora_user_id,
+                  'entityIds' => [zuora_entity_id.unpack("a8a4a4a4a12").join('-')],
+                  'customAuthorities' => [],
+                  'additionalInformation' => {
+                    'description' => "This user is for #{user} application.",
+                    'name' => "#{user} API User #{next_id}"
+                  }
+                }
+
+                oauth_response, response = zuora_client.rest_call(
+                  method: :post,
+                  body: body.to_json,
+                  url: zuora_client.rest_endpoint("genesis/clients").gsub('v1/', ''),
+                  session_type: zuora_client.class == ZuoraAPI::Oauth ? :bearer : :basic,
+                  headers: auth_headers
+                )
 
-                    available_entities = client_describe["accessibleEntities"].select {|entity| entity['id'] == zuora_entity_id}
-                    task_data = {
-                      "id": next_id,
-                      "name": client_describe["tenantName"],
-                      "mode": "Collections",
-                      "status": "Running",
-                      ZuoraConnect::AppInstance::LOGIN_TENANT_DESTINATION => {
-                        "tenant_type": "Zuora",
-                        "username": session["ZuoraCurrentIdentity"]["username"],
-                        "url": new_zuora_client.url,
-                        "status": "Active",
-                        "oauth_client_id": oauth_response['clientId'],
-                        "oauth_secret": oauth_response['clientSecret'],
-                        "authentication_type": "OAUTH",
-                        "entities": available_entities.map {|e| e.merge({'displayName' => client_describe["tenantName"]})}
-                      },
-                      "tenant_ids": available_entities.map{|e| e['entityId']}.uniq,
-                    }
-                  end
+                new_zuora_client = ZuoraAPI::Oauth.new(url: "https://#{zuora_host}", oauth_client_id: oauth_response["clientId"], oauth_secret: oauth_response["clientSecret"] )
+                if session["ZuoraCurrentUserInfo"].blank?
+                  client_describe, response = new_zuora_client.rest_call(url: zuora_client.rest_endpoint("genesis/user/info").gsub('v1/', ''), session_type: :bearer)
+                else
+                  client_describe = session["ZuoraCurrentUserInfo"]
+                end
 
-                  if defined?(@appinstance)
-                    @appinstance.zuora_logins = task_data
-                    @appinstance.save(:validate => false)
+                available_entities = client_describe["accessibleEntities"].select {|entity| entity['id'] == zuora_entity_id}
+                task_data = {
+                  "id": next_id,
+                  "name": client_describe["tenantName"],
+                  "mode": "Collections",
+                  "status": "Running",
+                  ZuoraConnect::AppInstance::LOGIN_TENANT_DESTINATION => {
+                    "tenant_type": "Zuora",
+                    "username": session["ZuoraCurrentIdentity"]["username"],
+                    "url": new_zuora_client.url,
+                    "status": "Active",
+                    "oauth_client_id": oauth_response['clientId'],
+                    "oauth_secret": oauth_response['clientSecret'],
+                    "authentication_type": "OAUTH",
+                    "entities": available_entities.map {|e| e.merge({'displayName' => client_describe["tenantName"]})}
+                  },
+                  "tenant_ids": available_entities.map{|e| e['entityId']}.uniq,
+                }
+                mapped_values = {:id => next_id, :api_token => rand(36**64).to_s(36), :token => rand(36**64).to_s(36), :zuora_logins => task_data, :oauth_expires_at => Time.now + 1000.years, :zuora_domain => zuora_client.rest_domain, :zuora_entity_ids => [zuora_entity_id]}
+                @appinstance = ZuoraConnect::AppInstance.new(mapped_values)
+                retry_count = 0
+                begin
+                  @appinstance.save(:validate => false)
+                rescue ActiveRecord::RecordNotUnique => ex
+                  if (retry_count += 1) < 3
+                    @appinstance.assign_attributes({:api_token => rand(36**64).to_s(36), :token => rand(36**64).to_s(36)})
+                    retry
                   else
-                    @appinstance = new_instance(
-                      next_id,
-                      zuora_entity_id,
-                      zuora_client.rest_domain,
-                      task_data: task_data,
-                      retry_count: retry_count
-                    )
+                    Thread.current[:appinstance] = nil
+                    session["appInstance"] = nil
+                    render "zuora_connect/static/error_handled", :locals => {
+                      :title => "Application could not create unique tokens.",
+                      :message => "Please contact support or retry launching application."
+                    }, :layout => false
+                    return
                   end
                 end
-              rescue ActiveRecord::RecordNotUnique
-                retry if (retry_count -= 1).positive?
-                return
               end
 
               Apartment::Tenant.switch!("public")
@@ -577,8 +483,8 @@ module ZuoraConnect
 
           rescue ZuoraAPI::Exceptions::ZuoraAPIError, Exception => ex
             if ex.message.include?("Referenced User resource(s) not found") && ex.class == ZuoraAPI::Exceptions::ZuoraAPIError
-              locals = {title: "Provisioning Error", message: "New tenants need to be provisioned by API Gateway('#{ex.message}'). Please contact support."}
-              render "zuora_connect/static/error_handled", locals: locals, status: 200, layout: false
+              locals = {title: "Provisioning Error", message: "New tenats need to be provisioned by API Gateway('#{ex.message}'). Please contact support."}
+              render "zuora_connect/static/error_handled", locals: locals, status: 400, layout: false
             else
               session.clear
               if defined?(ex.response) && ex.response.present? && defined?(ex.response.body)
@@ -634,50 +540,6 @@ module ZuoraConnect
         end
       end
 
-      def next_instance_id
-        min_instance_id = 24_999_999
-        (ZuoraConnect::AppInstance.all.where("id > #{min_instance_id}").order(id: :desc).limit(1).pluck(:id).first || min_instance_id) + 1
-      end
-
-      def new_instance(id, zuora_entity_id, rest_domain, task_data: nil, retry_count: 0)
-        app_instance = ZuoraConnect::AppInstance.new(
-          :id => id,
-          :api_token => generate_token,
-          :token => generate_token,
-          :oauth_expires_at => Time.now + 1000.years,
-          :zuora_domain => rest_domain,
-          :zuora_entity_ids => [zuora_entity_id]
-        )
-
-        if task_data.nil?
-          # no encryption
-          app_instance['zuora_logins'] = task_data
-        else
-          # kms encrypt
-          app_instance.zuora_logins = task_data
-        end
-
-        begin
-          app_instance.save(:validate => false)
-        rescue ActiveRecord::RecordNotUnique
-          raise if retry_count > 1
-
-          Thread.current[:appinstance] = nil
-          session['appInstance'] = nil
-          render 'zuora_connect/static/error_handled', :locals => {
-            :title => 'Application could not create unique tokens.',
-            :message => 'Please contact support or retry launching application.'
-          }, :layout => false
-          return
-        end
-
-        app_instance
-      end
-
-      def generate_token
-        rand(36**64).to_s(36)
-      end
-
       def setup_instance_via_dev_mode
         session["appInstance"] = ZuoraConnect.configuration.dev_mode_appinstance
         user = ZuoraConnect.configuration.dev_mode_user

data/lib/zuora_connect/railtie.rb

@@ -28,6 +28,11 @@ module ZuoraConnect
       ::Rails.configuration.action_dispatch.x_sendfile_header = nil
     end
 
+    if defined? Prometheus
+      initializer "prometheus.configure_rails_initialization" do |app|
+        app.middleware.use Prometheus::Middleware::Exporter,(options ={:path => '/connect/internal/metrics'})
+      end
+    end
     initializer "zuora_connect.configure_rails_initialization" do |app|
       app.middleware.insert_after Rack::Sendfile, ZuoraConnect::MetricsMiddleware
       app.middleware.insert_after ActionDispatch::RequestId, ZuoraConnect::RequestIdMiddleware
@@ -35,15 +40,6 @@ module ZuoraConnect
       app.config.middleware.use ZuoraConnect::JsonParseErrors
     end
 
-    if defined? Prometheus
-      require 'rack'
-      require 'prometheus/middleware/exporter'
-      initializer "prometheus.configure_rails_initialization" do |app|
-        app.middleware.insert_after ZuoraConnect::MetricsMiddleware, Prometheus::Middleware::Exporter, path: '/connect/internal/metrics'
-        app.config.middleware.use Rack::Deflater, if: ->(env, *) { env['PATH_INFO'] == '/connect/internal/metrics' }
-      end
-    end
-
     # hook to process_action
     ActiveSupport::Notifications.subscribe('process_action.action_controller', ZuoraConnect::PageRequest.new)
 
@@ -81,21 +77,6 @@ module ZuoraConnect
             request_headers =
               event.payload[:headers].env.
                 reject { |key| key.to_s.include?('.') || REQUEST_HEADERS_TO_IGNORE.include?(key.to_s) }
-            begin
-              if request_headers["HTTP_AUTHORIZATION"].present?
-                if request_headers["HTTP_AUTHORIZATION"].include?("Basic")
-                  user_password = request_headers["HTTP_AUTHORIZATION"].split("Basic").last.strip
-                  user, password = Base64.decode64(user_password).split(":")
-                  request_headers["HTTP_AUTHORIZATION"] = "Basic #{user}:ValueFiltered"
-                elsif 
-                  request_headers["HTTP_AUTHORIZATION"] = "ValueFiltered"
-                end
-              end
-              request_headers["HTTP_API_TOKEN"] = "ValueFiltered" if request_headers["HTTP_API_TOKEN"].present?
-            rescue
-              request_headers.delete("HTTP_API_TOKEN")
-              request_headers.delete("HTTP_AUTHORIZATION")
-            end
             items.merge!({ headers: request_headers.to_s })
           end
 

data/lib/zuora_connect/version.rb

@@ -1,3 +1,3 @@
 module ZuoraConnect
-  VERSION = "2.0.60l"
+  VERSION = "2.0.60"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zuora_connect
 version: !ruby/object:Gem::Version
-  version: 2.0.60l
+  version: 2.0.60
 platform: ruby
 authors:
 - Connect Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-11-04 00:00:00.000000000 Z
+date: 2020-07-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: apartment
@@ -429,53 +429,53 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Summary of Connect.
 test_files:
-- test/fixtures/zuora_connect/app_instances.yml
-- test/models/zuora_connect/app_instance_test.rb
 - test/integration/navigation_test.rb
 - test/controllers/zuora_connect/api/v1/app_instance_controller_test.rb
-- test/zuora_connect_test.rb
+- test/fixtures/zuora_connect/app_instances.yml
 - test/lib/generators/zuora_connect/datatable_generator_test.rb
-- test/dummy/public/500.html
-- test/dummy/public/404.html
-- test/dummy/public/favicon.ico
-- test/dummy/public/422.html
+- test/models/zuora_connect/app_instance_test.rb
+- test/zuora_connect_test.rb
 - test/dummy/Rakefile
 - test/dummy/config.ru
+- test/dummy/public/422.html
+- test/dummy/public/404.html
+- test/dummy/public/500.html
+- test/dummy/public/favicon.ico
+- test/dummy/app/controllers/application_controller.rb
+- test/dummy/app/helpers/application_helper.rb
+- test/dummy/app/views/layouts/application.html.erb
+- test/dummy/app/assets/javascripts/application.js
+- test/dummy/app/assets/stylesheets/application.css
+- test/dummy/README.rdoc
+- test/dummy/bin/rails
+- test/dummy/bin/rake
+- test/dummy/bin/bundle
+- test/dummy/bin/setup
 - test/dummy/config/secrets.yml
 - test/dummy/config/boot.rb
-- test/dummy/config/application.rb
+- test/dummy/config/initializers/mime_types.rb
+- test/dummy/config/initializers/filter_parameter_logging.rb
 - test/dummy/config/initializers/session_store.rb
+- test/dummy/config/initializers/inflections.rb
+- test/dummy/config/initializers/cookies_serializer.rb
 - test/dummy/config/initializers/assets.rb
 - test/dummy/config/initializers/wrap_parameters.rb
-- test/dummy/config/initializers/filter_parameter_logging.rb
 - test/dummy/config/initializers/backtrace_silencers.rb
-- test/dummy/config/initializers/mime_types.rb
-- test/dummy/config/initializers/inflections.rb
-- test/dummy/config/initializers/cookies_serializer.rb
-- test/dummy/config/routes.rb
 - test/dummy/config/database.yml
-- test/dummy/config/environments/test.rb
+- test/dummy/config/environment.rb
+- test/dummy/config/application.rb
+- test/dummy/config/routes.rb
 - test/dummy/config/environments/production.rb
 - test/dummy/config/environments/development.rb
-- test/dummy/config/environment.rb
+- test/dummy/config/environments/test.rb
 - test/dummy/config/locales/en.yml
-- test/dummy/README.rdoc
-- test/dummy/bin/rake
-- test/dummy/bin/setup
-- test/dummy/bin/rails
-- test/dummy/bin/bundle
-- test/dummy/app/views/layouts/application.html.erb
-- test/dummy/app/assets/javascripts/application.js
-- test/dummy/app/assets/stylesheets/application.css
-- test/dummy/app/helpers/application_helper.rb
-- test/dummy/app/controllers/application_controller.rb
 - test/test_helper.rb