zuora_connect 2.0.60u → 3.0.0.pre.b

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 92a983cff8e7ff831929da9496cbb34e728f2033e79135c8bb76fa604bd33e71
-  data.tar.gz: 67170a20afb4fee284cc402484e5770b47422ebbeb7652dca39ceab862ca4d20
+  metadata.gz: d7d9c3445983c015ce0615581bee9d36802b113c220caf4404f4bed697fc67ac
+  data.tar.gz: 29428d8aec94b04f215ac3faa5faba871cf1c21f60eb804abe6f501adafdb0ca
 SHA512:
-  metadata.gz: cb814342311b45d90903a72fff8d7bb9d313b91fb89346e99039276af4aae03ed538841215c9737ebc237d80a3584f3955c6e30e48a8e0c322ba7c7fd145ad78
-  data.tar.gz: 8f3d002f881cc6403baaae4f00bb88c8fff0f063c4a6290f4ad2c02c49361afe037717c6a55823a1834a9b29e3f16f11b2339211b992f83c42042133ebe33c55
+  metadata.gz: cb4cee9b6e964dbd417e758bf03e1a7cf1461d600e327110ad0155c5fd710e7083fb2d476697a24fe5d327a22eea4585982dbe1133b32b7c849a921a1004fe07
+  data.tar.gz: 7bd1393e58a2b341a2c64d8b8d870bbc13e906fa99ba22dd201a2afd250642505b1480469cfa5788dfd45215fe726b3af5a117d6eb80e623cc55e8d37bbd65cc

data/app/controllers/zuora_connect/static_controller.rb

@@ -1,16 +1,12 @@
 module ZuoraConnect
   class StaticController < ApplicationController
-    before_action :authenticate_connect_app_request, :except => [:metrics, :health, :initialize_app, :provision, :instance_user]
-    before_action :clear_connect_app_session,        :only =>   [:metrics, :health, :initialize_app, :provision, :instance_user]
-    after_action :persist_connect_app_session,       :except => [:metrics, :health, :initialize_app, :provision, :instance_user]
+    before_action :authenticate_connect_app_request, :except => [:health, :initialize_app, :provision, :instance_user]
+    before_action :clear_connect_app_session,        :only =>   [:health, :initialize_app, :provision, :instance_user]
+    after_action :persist_connect_app_session,       :except => [:health, :initialize_app, :provision, :instance_user]
 
     skip_before_action :verify_authenticity_token, :only => [:initialize_app, :provision]
     http_basic_authenticate_with name: ENV['PROVISION_USER'], password: ENV['PROVISION_SECRET'], :only => [:provision, :instance_user]
 
-    def metrics
-      type = params[:type].present? ? params[:type] : "versions"
-      render json: ZuoraConnect::AppInstance.get_metrics(type).to_json, status: 200
-    end
 
     def health
       if params[:error].present?

data/app/models/zuora_connect/app_instance_base.rb

@@ -12,7 +12,6 @@ module ZuoraConnect
 
     self.table_name = "zuora_connect_app_instances"
     attr_accessor :options, :mode, :logins, :task_data, :last_refresh, :username, :password, :s3_client, :api_version, :drop_message, :new_session_message, :connect_user, :logitems, :user_timezone
-    @@telegraf_host = nil
     REFRESH_TIMEOUT = 2.minute                #Used to determine how long to wait on current refresh call before executing another
     INSTANCE_REFRESH_WINDOW = 1.hours         #Used to set how how long till app starts attempting to refresh cached task connect data
     INSTANCE_REDIS_CACHE_PERIOD = 24.hours    #Used to determine how long to cached task data will live for
@@ -35,7 +34,7 @@ module ZuoraConnect
       Aws::Errors::MissingCredentialsError,
       Aws::S3::Errors::AccessDenied,
       Aws::SES::Errors::AccessDenied,
-      Aws::KMS::Errors::AccessDeniedException 
+      Aws::KMS::Errors::AccessDeniedException
     ].freeze
     AWS_AUTH_ERRORS_MSG = "AWS Auth Errors".freeze
 
@@ -169,6 +168,7 @@ module ZuoraConnect
         end
 
         self.build_task(task_data: mock_task_data, session: session)
+        self.set_backup_creds
         self.last_refresh = Time.now.to_i
       else
         time_expire = (session["#{self.id}::last_refresh"] || Time.now).to_i - INSTANCE_REFRESH_WINDOW.ago.to_i
@@ -263,7 +263,7 @@ module ZuoraConnect
         end
 
         params = {
-          name: self.task_data.dig('name'), 
+          name: self.task_data.dig('name'),
           zuora_entity_ids: (self.task_data.dig(LOGIN_TENANT_DESTINATION,'entities') || []).map{|e| e['id']}.uniq,
           zuora_tenant_ids: tenants.map(&:to_s).uniq,
           organizations: organizations
@@ -272,7 +272,7 @@ module ZuoraConnect
           client = self.send(LOGIN_TENANT_DESTINATION).client
           if defined?(client.rest_domain)
             ZuoraConnect::RequestIdMiddleware.zuora_rest_domain = client.rest_domain
-            params.merge!({zuora_domain: client.rest_domain, environment: client.environment }) 
+            params.merge!({zuora_domain: client.rest_domain, environment: client.environment })
           end
         end
         params = params.reject{|k,v| !self.attributes.keys.member?(k.to_s) || self[k] == v}
@@ -290,10 +290,7 @@ module ZuoraConnect
       elsif type == :user
         begin
           sql = <<-eos
-            SELECT zuora_users.zuora_identity_response 
-            FROM "#{self.id}".zuora_users 
-            ORDER BY zuora_users.updated_at DESC 
-            LIMIT 1;
+            SELECT zuora_users.zuora_identity_response FROM "#{self.id}".zuora_users ORDER BY zuora_users.updated_at DESC LIMIT 1;
           eos
           user = ActiveRecord::Base.connection.execute(sql).to_a.first
 
@@ -301,7 +298,10 @@ module ZuoraConnect
             zuora_identity_response = JSON.parse(user.fetch('zuora_identity_response', '{}'))
             self.user_timezone = zuora_identity_response.values.first&.dig('timeZone')
           else
-            Rails.logger.error('Cannot find any user to set the timezone', app_instance_id: self.id)
+            if (Redis.current.hget(TIMEZONE_LOG_RATE_LIMIT_KEY, self.id).to_i + TIMEZONE_LOG_PERIOD.to_i) <= Time.now.to_i
+              Rails.logger.error('Cannot find any user to set the timezone', app_instance_id: self.id)
+              Redis.current.hset(TIMEZONE_LOG_RATE_LIMIT_KEY, self.id, Time.now.to_i)
+            end
           end
         rescue => ex
           Rails.logger.error('There is an error while getting timezone users', ex)
@@ -345,12 +345,12 @@ module ZuoraConnect
       self.id >= 25000000
     end
 
-    def refresh(session: {}) 
+    def refresh(session: {})
       refresh_count ||= 0
       skip_connect ||= false
       begin
         #Check how app was deployed
-        if self.id < 25000000 && !skip_connect 
+        if !self.auto_deployed? && !skip_connect
           self.check_oauth_state
           response = HTTParty.get(ZuoraConnect.configuration.url + "/api/#{self.api_version}/tools/tasks/#{self.id}.json",:body => {:access_token => self.access_token})
 
@@ -362,16 +362,8 @@ module ZuoraConnect
             end
 
             self.build_task(task_data: parsed_json, session: session)  
-            if self.kms_key.present? && self.kms_key.match(/^arn:aws:.*/)
-              begin
-                self.zuora_logins = self.strip_cache_data(object: parsed_json.dup, keys: ['applications', 'tokens', 'user_settings'])
-                self.save(:validate => false)
-              rescue Aws::KMS::Errors::ValidationException, *AWS_AUTH_ERRORS => ex
-                Rails.logger.warn(AWS_AUTH_ERRORS_MSG, ex)
-              rescue => ex
-                Rails.logger.error(AWS_AUTH_ERRORS_MSG, ex)
-              end
-            end        
+            self.set_backup_creds
+            self.save(validate: false) if self.changed?    
           else
             raise ZuoraConnect::Exceptions::ConnectCommunicationError.new("Error Communicating with Connect", response.body, response.code)
           end
@@ -416,8 +408,16 @@ module ZuoraConnect
     end
 
     #### START KMS ENCRYPTION Methods ####
+      def set_backup_creds
+        if self.kms_key.present? && self.kms_key.match(/^arn:aws:.*/) && self.task_data.present?
+          self.zuora_logins = self.strip_cache_data(object: self.task_data.dup, keys: ['applications', 'tokens', 'user_settings'])
+        end  
+      end 
+
       def zuora_logins=(val)
         write_attribute(:zuora_logins, kms_encrypt(val.to_json))
+      rescue Aws::KMS::Errors::ValidationException, Aws::KMS::Errors::NotFoundException, *AWS_AUTH_ERRORS => ex
+        Rails.logger.warn(AWS_AUTH_ERRORS_MSG, ex)
       end
 
       def zuora_logins
@@ -477,82 +477,6 @@ module ZuoraConnect
         end
         Thread.current[:appinstance] = self
       end
-
-      def self.write_to_telegraf(*args)
-        if ZuoraConnect.configuration.enable_metrics && !defined?(Prometheus)
-          @@telegraf_host = ZuoraConnect::Telegraf.new() if @@telegraf_host == nil
-          unicorn_stats = self.unicorn_listener_stats() if defined?(Unicorn) && Unicorn.respond_to?(:listener_names)
-          @@telegraf_host.write(direction: 'Raindrops', tags: {}, values: unicorn_stats)  unless unicorn_stats.blank?
-          return @@telegraf_host.write(*args)
-        end
-      end
-
-      def self.unicorn_listener_stats ()
-        stats_hash = {}
-        stats_hash["total_active"] = 0
-        stats_hash["total_queued"] = 0
-
-        begin 
-          tmp = Unicorn.listener_names
-          unix = tmp.grep(%r{\A/})
-          tcp = tmp.grep(/\A.+:\d+\z/)
-          tcp = nil if tcp.empty?
-          unix = nil if unix.empty?
-
-
-          Raindrops::Linux.tcp_listener_stats(tcp).each do |addr,stats|
-            stats_hash["active_#{addr}"] = stats.active
-            stats_hash["queued_#{addr}"] = stats.queued
-            stats_hash["total_active"] = stats.active + stats_hash["total_active"]
-            stats_hash["total_queued"] = stats.queued + stats_hash["total_queued"]
-          end if tcp
-
-          Raindrops::Linux.unix_listener_stats(unix).each do |addr,stats|
-            stats_hash["active_#{addr}"] = stats.active
-            stats_hash["queued_#{addr}"] = stats.queued
-            stats_hash["total_active"] = stats.active + stats_hash["total_active"]
-            stats_hash["total_queued"] = stats.queued + stats_hash["total_queued"]
-          end if unix
-        rescue IOError => ex
-        rescue => ex
-          ZuoraConnect.logger.error(ex)
-        end
-        return stats_hash
-      end
-
-      def self.get_metrics(type)
-        @data = {}
-
-        if type == "versions"
-          @data = {
-            app_name: ZuoraConnect::Telegraf.app_name,
-            url: "dummy",
-            Version_Gem: ZuoraConnect::VERSION,
-            Version_Zuora: ZuoraAPI::VERSION ,
-            Version_Ruby: RUBY_VERSION,
-            Version_Rails: Rails.version,
-            hold: 1
-          }
-        elsif type == "stats"
-          begin
-            Resque.redis.ping
-            @resque = Resque.info
-            @data = {
-              app_name: ZuoraConnect::Telegraf.app_name,
-              url: "dummy",
-              Resque:{
-                Jobs_Finished: @resque[:processed] ,
-                Jobs_Failed: @resque[:failed],
-                Jobs_Pending: @resque[:pending],
-                Workers_Active: @resque[:working],
-                Workers_Total: @resque[:workers]
-              }
-            }
-          rescue
-          end
-        end
-        return @data
-      end
     #### END Task Methods ####
 
     #### START Task Methods ####
@@ -595,7 +519,7 @@ module ZuoraConnect
         end
       rescue ZuoraConnect::Exceptions::MissMatch => ex
         raise
-      rescue ZuoraConnect::Exceptions::InvalidCredentialSet => ex 
+      rescue ZuoraConnect::Exceptions::InvalidCredentialSet => ex
         raise
       rescue => ex
         ZuoraConnect.logger.error("Build Task Error", ex)
@@ -651,12 +575,12 @@ module ZuoraConnect
         self.refresh if !defined?(self.target_login)
 
         response = HTTParty.get("#{ZuoraConnect.configuration.url}/api/#{self.api_version}/tenants/search?hostname=#{self.target_login.client.hostname}&node_id=#{self.zuora_entity_ids.first}")
-       
+
         if response.success?
           parsed_json =  JSON.parse(response.body)
-          
+
           #Set Org
-          if self.id >= 25000000 && parsed_json['organization'].present?
+          if self.auto_deployed? && parsed_json['organization'].present?
             login_cache = self.zuora_logins
             login_cache.delete('organization')
             self.zuora_logins = login_cache.merge({'organizations' => [parsed_json['organization']]})
@@ -676,7 +600,7 @@ module ZuoraConnect
             end
           end
           self.save(:validate => false)
-         
+
           return parsed_json
         end
       rescue *(ZuoraAPI::Login::CONNECTION_EXCEPTIONS + ZuoraAPI::Login::CONNECTION_READ_EXCEPTIONS) => ex
@@ -730,7 +654,7 @@ module ZuoraConnect
       end
 
       def refresh_oauth
-        refresh_oauth_count ||= 0        
+        refresh_oauth_count ||= 0
         response = HTTParty.post("#{ZuoraConnect.configuration.url}/oauth/token", body: {
           :grant_type => "refresh_token",
           :redirect_uri => ZuoraConnect.configuration.oauth_client_redirect_uri,
@@ -1366,7 +1290,7 @@ module ZuoraConnect
 
     def self.without_sticking
        if self.connection.respond_to?(:without_sticking)
-        self.connection.without_sticking do 
+        self.connection.without_sticking do
           yield
         end
       else

data/config/initializers/prometheus.rb

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

data/config/initializers/redis.rb

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

data/config/initializers/resque.rb

@@ -36,13 +36,13 @@ Resque.module_eval do
 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)
+  Resque.logger = ZuoraObservability::Logger.custom_logger(name: "Resque", type: 'Monologger', level: MonoLogger::INFO)
+  Resque::Scheduler.logger = ZuoraObservability::Logger.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) 
+  Delayed::Worker.logger = ZuoraObservability::Logger.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)
+Makara::Logging::Logger.logger = ZuoraObservability::Logger.custom_logger(name: "Makara") if defined?(Makara)
+ElasticAPM.agent.config.logger = ZuoraObservability::Logger.custom_logger(name: "ElasticAPM", level: MonoLogger::WARN) if defined?(ElasticAPM) && ElasticAPM.running?
+ActionMailer::Base.logger = ZuoraObservability::Logger.custom_logger(name: "ActionMailer", type: 'Monologger') if defined?(ActionMailer)

data/config/initializers/unicorn.rb

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

data/config/routes.rb

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

data/lib/metrics/net.rb

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

data/lib/middleware/metrics_middleware.rb

@@ -17,7 +17,7 @@ module ZuoraConnect
       # 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? 
+      if payload[:exception].present?
         status_code, exception = [500, payload[:exception].first]
       else
         status_code, exception = [payload[:status], nil]
@@ -28,7 +28,7 @@ module ZuoraConnect
       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)
+      ZuoraObservability::Metrics.write_to_telegraf(direction: :inbound, tags: tags, values: values)
     end
   end
 
@@ -42,7 +42,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
@@ -66,14 +66,14 @@ module ZuoraConnect
 
         if defined?(Prometheus) && env['PATH_INFO'] == '/connect/internal/metrics'
           # Prometheus Stuff
-          metrics = ZuoraConnect::AppInstance.get_metrics('stats')
+          metrics = ZuoraObservability::Metrics.resque
           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|
+            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
@@ -84,14 +84,7 @@ module ZuoraConnect
         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
+        ensure
 
           # Uncomment following block of code for handling engine requests/requests without controller
           # else
@@ -112,7 +105,7 @@ module ZuoraConnect
 
               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
@@ -140,7 +133,7 @@ module ZuoraConnect
             gauge_name.to_sym,
             docstring: "#{key} metric",
             labels: %i(type name),
-            preset_labels: { type: type, name: ZuoraConnect::Telegraf.app_name },
+            preset_labels: { type: type, name: ZuoraObservability::Env.app_name },
             store_settings: most_recent_aggregation
           )
           gauge.set(value)

data/lib/zuora_connect.rb

@@ -9,12 +9,11 @@ require 'resque/silence_done'
 require 'resque/self_lookup'
 require 'resque/plugins/custom_logger'
 require 'resque/plugins/app_instance_job'
-require 'logging/connect_formatter'
-require 'metrics/influx/point_value'
 require 'metrics/net'
 require 'mono_logger'
 require 'zuora_connect/zuora_audit'
 require 'active_record'
+require 'zuora_observability'
 ::ActiveRecord::Base.send :include, ZuoraConnect::ZuoraAudit
 
 module ZuoraConnect
@@ -29,68 +28,9 @@ module ZuoraConnect
        when 'test'
         Rails.logger
       else
-        @logger ||= custom_logger(name: "Connect", level: Rails.logger.level)
+        @logger ||= ZuoraObservability::Logger.custom_logger(name: "Connect", level: Rails.logger.level)
       end
     end
-
-    def custom_logger(name: "", level: Rails.logger.present? ? Rails.logger.level : MonoLogger::INFO, type: :ougai)
-      #puts name + ' - ' + {Logger::WARN => 'Logger::WARN', Logger::ERROR => 'Logger::ERROR', Logger::DEBUG => 'Logger::DEBUG', Logger::INFO => 'Logger::INFO' }[level] + ' - '
-      if type == :ougai
-        require 'ougai'
-        require "ougai/formatters/customizable"
-        #logger = Ougai::Logger.new(MonoLogger.new(STDOUT))
-        logger = Ougai::Logger.new(STDOUT)
-        logger.level = level
-        if ZuoraConnect.configuration.json_logging
-          logger.formatter = Ougai::Formatters::ConnectFormatter.new(name)
-          logger.before_log = lambda do |data|
-            data[:trace_id] = ZuoraConnect::RequestIdMiddleware.request_id if ZuoraConnect::RequestIdMiddleware.request_id.present?
-            data[:zuora_trace_id] = ZuoraConnect::RequestIdMiddleware.zuora_request_id if ZuoraConnect::RequestIdMiddleware.zuora_request_id.present?
-            #data[:traces] = {amazon_id: data[:trace_id], zuora_id: data[:zuora_trace_id]}
-          end
-        else
-          logger.formatter = Ougai::Formatters::Customizable.new(
-            format_err: proc do |data|
-              next nil unless data.key?(:err)
-              err = data.delete(:err)
-              "  #{err[:name]} (#{err[:message]})\n #{err[:stack]}"
-            end,
-            format_data: proc do |data|
-              data.delete(:app_instance_id); data.delete(:tenant_ids); data.delete(:organization); data.delete(:environment)
-              format('%s %s: %s', 'DATA'.ljust(6), Time.now.strftime('%FT%T.%6NZ'), "#{data.to_json}") if data.present?
-            end,
-            format_msg: proc do |severity, datetime, _progname, data|
-              msg = data.delete(:msg)
-              format('%s %s: %s', severity.ljust(6), datetime, msg)
-            end
-          )
-          logger.formatter.datetime_format = '%FT%T.%6NZ'
-        end
-      else
-        logger = MonoLogger.new(STDOUT)
-        logger.level = level
-        logger.formatter =  proc do |serverity, datetime, progname, msg|
-          begin
-            msg = JSON.parse(msg)
-          rescue JSON::ParserError => ex
-          end
-          if ZuoraConnect.configuration.json_logging
-            require 'json'
-            store = {
-              name: name,
-              level: serverity,
-              timestamp: datetime.strftime('%FT%T.%6NZ'),
-              pid: Process.pid,
-              message: name == "ActionMailer" ? msg.strip : msg
-            }
-            JSON.dump(store) + "\n"
-          else
-            format('%s %s: %s', serverity.ljust(6), datetime, msg) + "\n"
-          end
-        end
-      end
-      return logger
-    end
   end
 
   module Controllers
@@ -147,7 +87,7 @@ module ZuoraConnect
       verify_server_cert: false,
       log_level: Logger::INFO,
       service_name: ENV['DEIS_APP'].present? ? ENV['DEIS_APP'] : Rails.application.class.parent_name,
-      logger: ZuoraConnect.custom_logger(name: "ElasticAPM", level: MonoLogger::WARN)
+      logger: ZuoraObservability::Logger.custom_logger(name: "ElasticAPM", level: MonoLogger::WARN)
     })
     defaults.merge!({disable_send: true}) if defined?(Rails::Console)
 

data/lib/zuora_connect/controllers/helpers.rb

@@ -677,10 +677,17 @@ module ZuoraConnect
 
       def setup_instance_via_dev_mode
         session["appInstance"] = ZuoraConnect.configuration.dev_mode_appinstance
-        user = ZuoraConnect.configuration.dev_mode_user
-        key = ZuoraConnect.configuration.dev_mode_pass
-        values = {:user => user , :key => key, :appinstance => session["appInstance"]}
-        @appinstance = ZuoraConnect::AppInstance.find_by(:id => values[:appinstance].to_i)
+        session["#{ZuoraConnect.configuration.dev_mode_appinstance}::admin"] =  ZuoraConnect.configuration.dev_mode_admin
+ 
+        values = {
+          id: ZuoraConnect.configuration.dev_mode_appinstance, 
+          access_token: ZuoraConnect.configuration.dev_mode_user, 
+          refresh_token: ZuoraConnect.configuration.dev_mode_pass, 
+          token: ZuoraConnect.configuration.dev_mode_pass+ZuoraConnect.configuration.dev_mode_pass, 
+          api_token: ZuoraConnect.configuration.dev_mode_pass+ZuoraConnect.configuration.dev_mode_pass
+        }
+        
+        @appinstance = ZuoraConnect::AppInstance.find_by(:id => ZuoraConnect.configuration.dev_mode_appinstance.to_i)
         ZuoraConnect::ZuoraUser.current_user_id = 0
         if @appinstance.blank?
           Apartment::Tenant.switch!("public")
@@ -690,14 +697,10 @@ module ZuoraConnect
             Apartment::Tenant.drop(values[:appinstance].to_s)
             retry
           end
-
-          @appinstance = ZuoraConnect::AppInstance.new(:id => values[:appinstance].to_i, :access_token => values[:user], :refresh_token => values[:key], :token => "#{values[:key]}#{values[:key]}", :api_token => "#{values[:key]}#{values[:key]}")
-          @appinstance.save(:validate => false)
-        end
-        if @appinstance.access_token.blank? || @appinstance.refresh_token.blank? || @appinstance.token.blank? || @appinstance.api_token.blank?
-          @appinstance.update_attributes!(:access_token =>  values["user"], :refresh_token =>  values["key"], :token => "#{values[:key]}#{values[:key]}", :api_token => "#{values[:key]}#{values[:key]}")
+          @appinstance = ZuoraConnect::AppInstance.new()
         end
-        session["#{@appinstance.id}::admin"] =  ZuoraConnect.configuration.dev_mode_admin
+        @appinstance.assign_attributes(values)
+        @appinstance.save(:validate => false)
       end
     end
   end

data/lib/zuora_connect/engine.rb

@@ -10,9 +10,10 @@ module ZuoraConnect
 
     initializer "connect", before: :load_config_initializers do |app|
       Rails.application.routes.prepend do
+        get '/connect/internal/data' => 'zuora_observability/metrics#metrics'
         mount ZuoraConnect::Engine, at: "/connect"
         match '/api/connect/health', via: :all, to: 'zuora_connect/static#health'
-        match '/api/connect/internal/data', via: :all, to: 'zuora_connect/static#metrics'
+        match '/api/connect/internal/data', via: :all, to: 'zuora_observability/metrics#metrics'
       end
     end
 

data/lib/zuora_connect/railtie.rb

@@ -46,68 +46,5 @@ module ZuoraConnect
 
     # hook to process_action
     ActiveSupport::Notifications.subscribe('process_action.action_controller', ZuoraConnect::PageRequest.new)
-
-    initializer(:rails_stdout_logging, before: :initialize_logger) do
-      require 'lograge'
-      
-      Rails.configuration.logger = ZuoraConnect.custom_logger(name: "Rails") 
-      if !Rails.env.test? && !Rails.env.development?
-        Rails.configuration.lograge.enabled = true
-        Rails.configuration.colorize_logging = false
-      end
-
-      if Rails.configuration.lograge.enabled
-        if Rails.configuration.logger.class.to_s == 'Ougai::Logger'
-          Rails.configuration.lograge.formatter = Class.new do |fmt|
-            def fmt.call(data)
-              { msg: 'Rails Request', request: data }
-            end
-          end
-        end
-        #Rails.configuration.lograge.formatter = Lograge::Formatters::Json.new
-        Rails.configuration.lograge.custom_options = lambda do |event|
-          exceptions = %w(controller action format)
-          items = {
-            #time: event.time.strftime('%FT%T.%6N'),  
-            params: event.payload[:params].as_json(except: exceptions).to_json.to_s
-          }
-          items.merge!({exception_object: event.payload[:exception_object]}) if event.payload[:exception_object].present?
-          items.merge!({exception: event.payload[:exception]}) if event.payload[:exception].present?
-
-          if event.payload[:headers].present?
-            # By convertion, headers usually do not have dots. Nginx even rejects headers with dots
-            # All Rails headers are namespaced, like 'rack.input'.
-            # Thus, we can obtain the client headers by rejecting dots
-            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
-
-          if Thread.current[:appinstance].present? 
-            items.merge!({connect_user: Thread.current[:appinstance].connect_user, new_session: Thread.current[:appinstance].new_session_message})
-            if Thread.current[:appinstance].logitems.present? && Thread.current[:appinstance].logitems.class == Hash
-              items.merge!(Thread.current[:appinstance].logitems)
-            end
-          end
-          return items        
-        end
-      end
-    end
   end
 end

data/lib/zuora_connect/version.rb

@@ -1,3 +1,3 @@
 module ZuoraConnect
-  VERSION = "2.0.60u"
+  VERSION = "3.0.0-b"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zuora_connect
 version: !ruby/object:Gem::Version
-  version: 2.0.60u
+  version: 3.0.0.pre.b
 platform: ruby
 authors:
 - Connect Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-11-18 00:00:00.000000000 Z
+date: 2020-12-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: apartment
@@ -182,6 +182,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: zuora_observability
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -318,7 +332,6 @@ files:
 - app/models/zuora_connect/app_instance.rb
 - app/models/zuora_connect/app_instance_base.rb
 - app/models/zuora_connect/login.rb
-- app/models/zuora_connect/telegraf.rb
 - app/models/zuora_connect/zuora_user.rb
 - app/views/layouts/zuora_connect/application.html.erb
 - app/views/sql/refresh_aggregate_table.txt
@@ -353,8 +366,6 @@ files:
 - db/migrate/20190520232222_add_unique_index.rb
 - db/migrate/20190520232223_add_provisioning_fields.rb
 - db/migrate/20190520232224_add_environment_fields.rb
-- lib/logging/connect_formatter.rb
-- lib/metrics/influx/point_value.rb
 - lib/metrics/net.rb
 - lib/middleware/bad_multipart_form_data_sanitizer.rb
 - lib/middleware/json_parse_errors.rb

data/app/models/zuora_connect/telegraf.rb

@@ -1,97 +0,0 @@
-module ZuoraConnect
-  class Telegraf
-    attr_accessor :host
-
-    OUTBOUND_METRICS = true      
-    OUTBOUND_METRICS_NAME = "request-outbound"      
-    INBOUND_METRICS = true      
-    INBOUND_METRICS_NAME = "request-inbound"      
-
-    def initialize 
-      self.connect
-    end
-
-    def connect
-      ZuoraConnect.logger.debug(self.format_metric_log('Telegraf','Need new connection')) if ZuoraConnect.configuration.telegraf_debug
-      uri = URI.parse(ZuoraConnect.configuration.telegraf_endpoint)
-      self.host = UDPSocket.new.tap do |socket|
-        socket.connect uri.host, uri.port
-      end
-    rescue => ex
-      self.host = nil
-      ZuoraConnect.logger.warn(self.format_metric_log('Telegraf', "Failed to connect: #{ex.class}")) if Rails.env.to_s != 'production'
-    end
-
-    def write(direction: 'Unknown', tags: {}, values: {})
-      time = Benchmark.measure do |bench|
-        # To avoid writing metrics from rspec tests
-        if Rails.env.to_sym != :test
-          app_instance = Thread.current[:appinstance].present? ? Thread.current[:appinstance].id : 0
-          tags = { app_name: self.class.app_name, process_type: self.class.process_type, app_instance: app_instance, pod_name: self.class.pod_name}.merge(tags)
-
-          if direction == :inbound
-            if INBOUND_METRICS && !Thread.current[:inbound_metric].to_bool
-              self.write_udp(series: INBOUND_METRICS_NAME, tags: tags, values: values) 
-              Thread.current[:inbound_metric] = true
-            else
-              return
-            end
-          elsif direction == :outbound
-            self.write_udp(series: OUTBOUND_METRICS_NAME, tags: tags, values: values) if OUTBOUND_METRICS
-          else
-            self.write_udp(series: direction, tags: tags, values: values)
-          end
-        end
-      end
-      if ZuoraConnect.configuration.telegraf_debug
-        ZuoraConnect.logger.debug(self.format_metric_log('Telegraf', tags.to_s))
-        ZuoraConnect.logger.debug(self.format_metric_log('Telegraf', values.to_s))
-        ZuoraConnect.logger.debug(self.format_metric_log('Telegraf', "Writing '#{direction.capitalize}': #{time.real.round(5)} ms"))
-      end
-    end
-
-
-    def write_udp(series: '', tags: {}, values: {})
-      return if !values.present?
-      self.host.write InfluxDB::PointValue.new({series: series, tags: tags, values: values}).dump 
-    rescue => ex
-      self.connect
-      ZuoraConnect.logger.warn(self.format_metric_log('Telegraf',"Failed to write udp: #{ex.class}")) if Rails.env.to_s != 'production'
-    end
-
-    def format_metric_log(message, dump = nil)
-      message_color, dump_color = "1;91", "0;1"
-      log_entry = "  \e[#{message_color}m#{message}\e[0m   "
-      log_entry << "\e[#{dump_color}m%#{String === dump ? 's' : 'p'}\e[0m" % dump if dump
-      if Rails.env == :development
-        log_entry
-      else
-        [message, dump].compact.join(' - ')
-      end
-    end
-
-    def self.app_name
-      return ENV['DEIS_APP'].present? ? ENV['DEIS_APP'] : Rails.application.class.parent_name
-    end
-
-    def self.pod_name
-      return ENV['HOSTNAME'].present? ? ENV['HOSTNAME'] :  Socket.gethostname
-    end
-
-    def self.full_process_name(process_name: nil, function: nil)
-      keys = [self.pod_name, process_name.present? ? process_name : self.process_type, Process.pid, function]
-      return keys.compact.join('][').prepend('[').concat(']')
-    end
-
-    # Returns the process type if any
-    def self.process_type(default: 'Unknown')
-      p_type = default
-      if ENV['HOSTNAME'] && ENV['DEIS_APP']
-        temp = ENV['HOSTNAME'].split(ENV['DEIS_APP'])[1]
-        temp = temp.split(/(-[0-9a-zA-Z]{5})$/)[0] # remove the 5 char hash
-        p_type = temp[1, temp.rindex("-")-1]
-      end
-      return p_type
-    end
-  end
-end

data/lib/logging/connect_formatter.rb

@@ -1,44 +0,0 @@
-require 'ougai/formatters/base'
-require 'ougai/formatters/for_json'
-
-module Ougai
-  module Formatters
-    # A JSON formatter compatible with node-bunyan
-    class ConnectFormatter < Base
-      include ForJson
-
-      # Intialize a formatter
-      # @param [String] app_name application name (execution program name if nil)
-      # @param [String] hostname hostname (hostname if nil)
-      # @param [Hash] opts the initial values of attributes
-      # @option opts [String] :trace_indent (2) the value of trace_indent attribute
-      # @option opts [String] :trace_max_lines (100) the value of trace_max_lines attribute
-      # @option opts [String] :serialize_backtrace (true) the value of serialize_backtrace attribute
-      # @option opts [String] :jsonize (true) the value of jsonize attribute
-      # @option opts [String] :with_newline (true) the value of with_newline attribute
-      def initialize(app_name = nil, hostname = nil, opts = {})
-        aname, hname, opts = Base.parse_new_params([app_name, hostname, opts])
-        super(aname, hname, opts)
-        init_opts_for_json(opts)
-      end
-
-      def _call(severity, time, progname, data)
-        data.merge!({message: data.delete(:msg)})
-        if data[:timestamp].present?
-          time = data[:timestamp]
-          data.delete(:timestamp)
-        end
-        dump({
-          name: progname || @app_name,
-          pid: $$,
-          level: severity,
-          timestamp: time.utc.strftime('%FT%T.%6NZ'),
-        }.merge(data))
-      end
-
-      def convert_time(data)
-        #data[:timestamp] = format_datetime(data[:time])
-      end
-    end
-  end
-end

data/lib/metrics/influx/point_value.rb

@@ -1,79 +0,0 @@
-module InfluxDB
-  # Convert data point to string using Line protocol
-  class PointValue
-    attr_reader :series, :values, :tags, :timestamp
-
-    def initialize(data)
-      @series    = escape data[:series], :measurement
-      @values    = escape_values data[:values]
-      @tags      = escape_tags data[:tags]
-      @timestamp = data[:timestamp]
-    end
-
-    def dump
-      dump =  @series.dup
-      dump << ",#{@tags}" if @tags
-      dump << " #{@values}"
-      dump << " #{@timestamp}" if @timestamp
-      dump
-    end
-
-    private
-
-    ESCAPES = {
-      measurement:  [' '.freeze, ','.freeze],
-      tag_key:      ['='.freeze, ' '.freeze, ','.freeze],
-      tag_value:    ['='.freeze, ' '.freeze, ','.freeze],
-      field_key:    ['='.freeze, ' '.freeze, ','.freeze, '"'.freeze],
-      field_value:  ["\\".freeze, '"'.freeze],
-    }.freeze
-
-    private_constant :ESCAPES
-
-    def escape(str, type)
-      # rubocop:disable Layout/AlignParameters
-      str = str.encode "UTF-8".freeze, "UTF-8".freeze,
-        invalid: :replace,
-        undef: :replace,
-        replace: "".freeze
-      # rubocop:enable Layout/AlignParameters
-
-      ESCAPES[type].each do |ch|
-        str = str.gsub(ch) { "\\#{ch}" }
-      end
-      str
-    end
-
-    def escape_values(values)
-      return if values.nil?
-      values.map do |k, v|
-        key = escape(k.to_s, :field_key)
-        val = escape_value(v)
-        "#{key}=#{val}"
-      end.join(",".freeze)
-    end
-
-    def escape_value(value)
-      if value.is_a?(String)
-        '"'.freeze + escape(value, :field_value) + '"'.freeze
-      elsif value.is_a?(Integer)
-        "#{value}i"
-      else
-        value.to_s
-      end
-    end
-
-    def escape_tags(tags)
-      return if tags.nil?
-
-      tags = tags.map do |k, v|
-        key = escape(k.to_s, :tag_key)
-        val = escape(v.to_s, :tag_value)
-
-        "#{key}=#{val}" unless key == "".freeze || val == "".freeze
-      end.compact
-
-      tags.join(",") unless tags.empty?
-    end
-  end
-end