zuora_connect 2.1.1 → 3.0.0.pre.e

data/app/models/zuora_connect/zuora_user.rb

@@ -2,6 +2,6 @@ module ZuoraConnect
   class ZuoraUser < ActiveRecord::Base
     self.table_name = "zuora_users"
     attr_accessor :session
-
+    cattr_accessor :current_user_id
   end
 end

data/config/initializers/postgresql_adapter.rb

@@ -1,9 +1,15 @@
 module ActiveRecord
   module ConnectionAdapters
     class PostgreSQLAdapter < AbstractAdapter
+
+      SCHEMA_ADDITIONAL_TYPES = 'SchemaAdditionalTypes'.freeze
+
       private
-        def load_additional_types(type_map, oids = nil)
+        def load_additional_types_latest(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
@@ -24,9 +30,73 @@ 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,38 +3,95 @@ 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
+      rescue
+        # Ignored
+      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: 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)
 
-    # 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: 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)
+      UNICORN_KILLS = prometheus.gauge(
+        :unicorn_kills,
+        docstring: 'Unicorn Kills',
+        labels: %i(type name),
+        preset_labels: {type:'Unicorn-Killer', name: ZuoraObservability::Env.app_name},
+        store_settings: sum_aggregation
+      )
+
+      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: ZuoraObservability::Env.app_name },
+          store_settings: most_recent_aggregation
+        )
+        Prometheus.const_set(
+          gauge_name.upcase,
+          gauge
+        )
+      end
+    end
   end
 end

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

@@ -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
@@ -20,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

@@ -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
+        ZuoraObservability::Metrics.write_to_telegraf(direction: 'Unicorn-Killer', tags: {app_instance: 0}, values: {kill: 1})
+      end
     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

@@ -1,8 +1,12 @@
 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?
+    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/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

data/lib/middleware/json_parse_errors.rb

@@ -7,7 +7,7 @@ module ZuoraConnect
     def call(env)
       begin
         @app.call(env)
-      rescue ActionDispatch::ParamsParser::ParseError => error
+      rescue DynamicRailsError => error
         if env['HTTP_ACCEPT'] =~ /application\/json/ || env['CONTENT_TYPE'] =~ /application\/json/
           return [
             400, { "Content-Type" => "application/json" },
@@ -18,5 +18,16 @@ 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

@@ -1,37 +1,6 @@
 module ZuoraConnect
   require 'uri'
 
-  # Object of this class is passed to the ActiveSupport::Notification hook
-  class PageRequest
-
-    # This method is triggered when a non error page is loaded (not 404)
-    def call(name, started, finished, unique_id, payload)
-      # If the url contains any css or JavaScript files then do not collect metrics for them
-      return nil if ["css", "assets", "jpg", "png", "jpeg", "ico"].any? { |word| payload[:path].include?(word) }
-
-      # Getting the endpoint and the content_type
-      content_hash = {:html => "text/html", :js => "application/javascript", :json => "application/json", :csv => "text/csv"}
-      content_type = content_hash.key?(payload[:format]) ? content_hash[payload[:format]] : payload[:format]
-      content_type = content_type.to_s.gsub('text/javascript', 'application/javascript')
-
-      # payloads with 500 requests do not have status as it is not set by the controller
-      # https://github.com/rails/rails/issues/33335
-      #status_code = payload[:status] ? payload[:status] : payload[:exception_object].present? ? 500 : ""
-      if payload[:exception].present? 
-        status_code, exception = [500, payload[:exception].first]
-      else
-        status_code, exception = [payload[:status], nil]
-      end
-
-      tags = {method: payload[:method], status: status_code, error_type: exception, content_type: content_type, controller: payload[:controller], action: payload[:action]}.compact
-
-      values = {view_time: payload[:view_runtime], db_time: payload[:db_runtime], response_time: ((finished-started)*1000)}.compact
-      values = values.map{ |k,v| [k,v.round(2)]}.to_h
-
-      ZuoraConnect::AppInstanceBase.write_to_telegraf(direction: :inbound, tags: tags, values: values)
-    end
-  end
-
   class MetricsMiddleware
 
     require "zuora_connect/version"
@@ -42,7 +11,7 @@ module ZuoraConnect
     end
 
     def call(env)
-      @bad_headers = ["HTTP_X_FORWARDED_FOR", "HTTP_X_FORWARDED_HOST", "HTTP_X_FORWARDED_PORT", "HTTP_X_FORWARDED_PROTO", "HTTP_X_FORWARDED_SCHEME", "HTTP_X_FORWARDED_SSL"] 
+      @bad_headers = ["HTTP_X_FORWARDED_FOR", "HTTP_X_FORWARDED_HOST", "HTTP_X_FORWARDED_PORT", "HTTP_X_FORWARDED_PROTO", "HTTP_X_FORWARDED_SCHEME", "HTTP_X_FORWARDED_SSL"]
       if !ActionDispatch::Request::HTTP_METHODS.include?(env["REQUEST_METHOD"].upcase)
         [405, {"Content-Type" => "text/plain"}, ["Method Not Allowed"]]
       else
@@ -64,47 +33,27 @@ module ZuoraConnect
         #Remove bad headers
         @bad_headers.each { |header| env.delete(header) }
 
-        #Thread.current[:appinstance] = nil
-        start_time = Time.now
-        begin
-          @status, @headers, @response = @app.call(env)
-        ensure 
-          
-          # If the url contains any CSS or JavaScript files then do not collect metrics for them
-          if ["css", "assets", "jpg", "png", "jpeg", "ico"].any? { |word| env['PATH_INFO'].include?(word) } || /.*\.js$/.match(env['PATH_INFO'])
-            tags = {status: @status, controller: 'ActionController', action: 'Assets', app_instance: 0}
-            values = {response_time: ((Time.now - start_time)*1000).round(2) }
-            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])
+        if defined?(Prometheus) && env['PATH_INFO'] == '/connect/internal/metrics'
+          # Prometheus Stuff
+          metrics = ZuoraObservability::Metrics.resque
+          redis_up = metrics.present? && metrics.dig(:Resque, :Workers_Total).present? ? 1 : 0
+          Prometheus::REDIS_CONNECTION.set(redis_up)
 
-                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
+          process_prometheus_metric(metrics: metrics)
 
+          if defined?(Unicorn) && Unicorn.respond_to?(:listener_names)
+            ZuoraObservability::Metrics.unicorn_listener.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
+          @status, @headers, @response = @app.call(env)
+        ensure
 
           # Uncomment following block of code for handling engine requests/requests without controller
           # else
@@ -119,13 +68,13 @@ 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)
+              ZuoraObservability::Metrics.write_to_telegraf(direction: :inbound, tags: tags, values: values)
             end
           end
           Thread.current[:inbound_metric] = nil
@@ -133,5 +82,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: ZuoraObservability::Env.app_name },
+            store_settings: most_recent_aggregation
+          )
+          gauge.set(value)
+        end
+      end
+    end
   end
 end