zuora_connect 2.0.58 → 2.0.60c

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b0443ea374a1f1f82e212960a7df80fb9aa953fb4bf0fcb123949e73dfc622d
-  data.tar.gz: a356f5120206bf8febbdca0db439c5792dca19156776356f09f5a39da50cf7b1
+  metadata.gz: 8befa7a7baeaf53305dc7cca304df5e672f0702a79a466a527a0f21a5ae0ab22
+  data.tar.gz: 6fe3d6e3390df915df0f3d49815a2cf4326035815a9b240b945d206941cb8032
 SHA512:
-  metadata.gz: 34e40410cfcd4752b174d584d2cf883084630b56e7e4d897733da177fa66ece76c9ec3b2556e0ea3778b05eed949c6dba9e4c37f635d178fb9d77f776ec5221f
-  data.tar.gz: '08dde90f26d809089f79928c0cfa6d7c43d551b61448b7ce040b0ba05aa64552599ff3e3c49f46feb54340d846565faa75f891730501e2ad1ffe6a8c554856e5'
+  metadata.gz: 92604604be323a0e43faa74ece5ba4ace4c86ae79710d86164850acfeee6990ec07fdbe6c6a674e5aa9f1ab1d0a93bf2d593052cc47d5290fd04d6cf59037fc8
+  data.tar.gz: 6ebb61f4e49c43d426fb0bcb2dd8070d5e720ce645ded094aa132686740cd1a2706c6b6b070794fa411ce162fcb0944291091b81485c4486cb8f3bed7710b191

data/app/controllers/zuora_connect/static_controller.rb

@@ -1,10 +1,11 @@
 module ZuoraConnect
   class StaticController < ApplicationController
-    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]
+    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]
 
     def metrics
       type = params[:type].present? ? params[:type] : "versions"
@@ -13,11 +14,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
@@ -34,11 +35,13 @@ module ZuoraConnect
     def initialize_app
       begin
         authenticate_connect_app_request
-        @appinstance.new_session(:session => @appinstance.data_lookup(:session => session))
-        render json: {
-          message: "Success",
-          status: 200
-        }, status: 200
+        unless performed?
+          @appinstance.new_session(:session => @appinstance.data_lookup(:session => session))
+          render json: {
+            message: 'Success',
+            status: 200
+          }, status: 200
+        end
       rescue => ex
         Rails.logger.error("Failed to Initialize application", ex)
         if performed?
@@ -52,6 +55,74 @@ 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

@@ -402,7 +402,7 @@ module ZuoraConnect
       end
 
       def self.write_to_telegraf(*args)
-        if ZuoraConnect.configuration.enable_metrics
+        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?

data/config/initializers/prometheus.rb

@@ -3,38 +3,93 @@ 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::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 = 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)
 
-    # 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)
+    ZUORA_VERSION.set(0)
+    CONNECT_VERSION.set(0)
+    RAILS_VERSION.set(0)
+    RUBY_V.set(0)
 
     # Do they have resque jobs?
     if defined? Resque.redis
-      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)
-
+      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
+      )
+
+      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,6 +5,20 @@ 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,7 +3,35 @@ 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)
-      ZuoraConnect::AppInstance.write_to_telegraf(direction: 'Unicorn-Killer', tags: {app_instance: 0}, values: {kill: 1})
+      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
     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,6 +3,11 @@ 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/metrics_middleware.rb

@@ -64,6 +64,22 @@ 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
@@ -77,35 +93,6 @@ 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)
@@ -119,10 +106,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)
@@ -133,5 +120,32 @@ 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/plugins/app_instance_job.rb

@@ -47,7 +47,7 @@ module Resque
             raise
           end
         rescue PG::ConnectionBad => exception
-          Rails.logger.info("Bad Connection Restart")
+          Rails.logger.warn("Bad Connection Restart", exception)
           Resque.enqueue_to(self.job.queue, self.job.payload['class'], args)
           return
         rescue ZuoraConnect::Exceptions::ConnectCommunicationError => exception

data/lib/zuora_connect/controllers/helpers.rb

@@ -219,6 +219,80 @@ 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']
@@ -226,7 +300,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"] || "apisandbox.zuora.com"
+          zuora_host = request.headers['HTTP_X_FORWARDED_HOST'] || request.headers['Zuora-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 = {}
@@ -272,7 +346,7 @@ module ZuoraConnect
               ##
               # If the ZSession was refreshed, but it's still the same user and they aren't launching from the side bar,
               # we don't need to continue
-              is_different_user = identity.slice("entityId", "tenantId", "userId", "userProfileId") == (session["ZuoraCurrentIdentity"] || {}).slice("entityId", "tenantId", "userId", "userProfileId")
+              is_different_user = identity.slice("entityId", "tenantId", "userId", "userProfileId") != (session["ZuoraCurrentIdentity"] || {}).slice("entityId", "tenantId", "userId", "userProfileId")
               zuora_details["identity"]["entityId"] = identity['entityId']
               session["ZuoraCurrentIdentity"] = identity
               session["ZuoraCurrentEntity"] = identity['entityId']
@@ -328,11 +402,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
                 @zuora_user = ZuoraConnect::ZuoraUser.where(:zuora_user_id => zuora_user_id).first
@@ -380,79 +456,85 @@ module ZuoraConnect
                 return
               end
               Apartment::Tenant.switch!("public")
-              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)
+              retry_count = 3
+              task_data = {}
+              begin
+                ActiveRecord::Base.transaction do
+                  ActiveRecord::Base.connection.execute('LOCK public.zuora_users IN ACCESS EXCLUSIVE MODE')
 
-                if appinstances.size > 0
-                  redirect_to "https://#{zuora_host}/apps/newlogin.do?retURL=#{request.fullpath}"
-                  return
-                end
+                  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)
 
-                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
-                )
+                    if appinstances.size > 0
+                      redirect_to "https://#{zuora_host}/apps/newlogin.do?retURL=#{request.fullpath}"
+                      return
+                    end
+                  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
+                  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
 
-                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
+                    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
+
+                  if defined?(@appinstance)
+                    @appinstance.zuora_logins = task_data
+                    @appinstance.save(:validate => false)
                   else
-                    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
+                    @appinstance = new_instance(
+                      next_id,
+                      zuora_entity_id,
+                      zuora_client.rest_domain,
+                      task_data: task_data,
+                      retry_count: retry_count
+                    )
                   end
                 end
+              rescue ActiveRecord::RecordNotUnique
+                retry if (retry_count -= 1).positive?
+                return
               end
 
               Apartment::Tenant.switch!("public")
@@ -540,6 +622,50 @@ 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,11 +28,6 @@ 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
@@ -40,6 +35,15 @@ 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)
 

data/lib/zuora_connect/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zuora_connect
 version: !ruby/object:Gem::Version
-  version: 2.0.58
+  version: 2.0.60c
 platform: ruby
 authors:
 - Connect Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-06-26 00:00:00.000000000 Z
+date: 2020-08-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: apartment
@@ -429,9 +429,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.0.3
 signing_key: