zuora_connect 1.6.05 → 1.6.06

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 453d594fb07a0bff60f8e49caaecaf6946b9cae9
-  data.tar.gz: d748b6246b8978f0c11540034061ee38ea9aca75
+  metadata.gz: 3aab6b6790b92249ea03f26bf79222ec77720566
+  data.tar.gz: 5f09e4567ab8a4bdac1defe735a5b43809295dd9
 SHA512:
-  metadata.gz: 1a760b5accc67e3b0053e30e7f70f3661804de2f4742a04615e63b548710ce9bda1505843549523b26371f16d8241fa50a538ddc9bd5d0caac2e2afa1e5d0038
-  data.tar.gz: 2f0cac559a7556f6eab011d8983bbbfd54ea3af321b31f7431099a211c8473480edd99e6db45ab8a3e7152a66fdad60121b9bc99ab9186248b4cb881f2892542
+  metadata.gz: 9b20a0da49a4ee3ff62950fb04419a5d3a98fe1d381ed9b9bcc04c7564c8e9d053db136740a82ff74ad950ce47e094aa63b66739dc35ba1a7d4924c95ab4541b
+  data.tar.gz: fe902be31ee9eb458cc92204cc4addb4ea50a973973247b6a1d44fb1b670a0d0dc35b1644ac5ff8248741b1926dd589e8d17372b1199975530fb98ddbc65a2b9

data/app/controllers/zuora_connect/api/v1/app_instance_controller.rb

@@ -13,17 +13,25 @@ module ZuoraConnect
     def drop
       instance_id = @appinstance.id
       if session["#{instance_id}::destroy"] && ZuoraConnect::AppInstance.where(:id => instance_id).size != 0
-        ZuoraConnect::AppInstance.destroy(instance_id)
-        msg = Apartment::Tenant.drop(instance_id)
-        respond_to do |format|
-          message = Hash.new
-          message = {"error" => {:message => msg.error_message}} if msg.error_message != ""
-          message["message"] = msg.result_status == 1 ? "success" : "error"
-          format.json {render :json => message}
+        if @appinstance.drop_instance
+          ZuoraConnect::AppInstance.destroy(instance_id)
+          msg = Apartment::Tenant.drop(instance_id)
+
+          respond_to do |format|
+            if msg.error_message.present?
+              format.json {render json: {"message" => msg.error_message}, status: :bad_request }
+            else
+              format.json {render json: {}, status: :ok}
+            end
+          end
+        else
+          respond_to do |format|
+            format.json {render json: {"message" => @appinstance.drop_message}, status: :bad_request}
+          end
         end
       else
         respond_to do |format|
-          format.json {render :json => { "message" => "Unauthorized"}}
+          format.json { render json: { "message" => "Unauthorized"}, status:  :unauthorized }
         end
       end
     end

data/app/models/zuora_connect/app_instance_base.rb

@@ -4,8 +4,8 @@ module ZuoraConnect
     default_scope {select(ZuoraConnect::AppInstance.column_names.delete_if {|x| ["catalog_mapping", "catalog"].include?(x) }) }
     after_initialize :init
     self.table_name = "zuora_connect_app_instances"
-    attr_accessor :options, :mode, :logins, :task_data, :last_refresh, :username, :password, :s3_client, :api_version
-
+    attr_accessor :options, :mode, :logins, :task_data, :last_refresh, :username, :password, :s3_client, :api_version, :drop_message
+    @@telegraf_host = nil
     REFRESH_TIMEOUT = 2.minute                #Used to determine how long to wait on current refresh call before executing another
     INSTANCE_REFRESH_WINDOW = 30.minutes      #Used to set how how long till app starts attempting to refresh cached task connect data
     INSTANCE_REDIS_CACHE_PERIOD = 60.minutes  #Used to determine how long to cached task data will live for
@@ -25,12 +25,31 @@ module ZuoraConnect
       self.apartment_switch(nil, true)
     end
 
+    def self.write_metric(series: 'Unknown', tags: {}, values: {})
+      begin
+        if @@telegraf_host.blank?
+          Rails.logger.debug('Need new connection') if ZuoraConnect.configuration.telegraf_debug
+          uri = URI.parse(ZuoraConnect.configuration.telegraf_endpoint)
+          @@telegraf_host = UDPSocket.new.tap do |socket|
+            socket.connect uri.host, uri.port
+          end
+        end
+        @@telegraf_host.write InfluxDB::PointValue.new({series: series, tags: tags, values: values}).dump 
+      rescue => ex
+        @@telegraf_host = nil
+        Rails.logger.tagged("Telegraf") do 
+          logger.warn('Failed to write')
+          logger.warn(ex.class)
+          logger.warn(ex.message)
+        end
+      end
+    end
 
     # Methods for writing Telegraf metrics
 
     # Returns the process type if any
     def self.get_process_type
-      p_type = nil
+      p_type = 'Unknown'
       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
@@ -40,57 +59,31 @@ module ZuoraConnect
     end
 
     # Write to telegraf
-    def self.write_to_telegraf(endpoint_name: nil, method_name: nil, status_code: nil, response_time: nil, db_runtime: nil, view_runtime: nil, content_type: nil, direction: nil, error_type: nil, app_instance: nil, function_name: nil)
-
-      # To avoid writing metrics from rspec tests
-      if ENV['DEIS_APP']
-        # Getting the process type
-        p_type = ZuoraConnect::AppInstanceBase.get_process_type
-
-        if direction == "inbound" && ZuoraConnect.configuration.enable_inbound_metrics_flag
-          Thread.current[:appinstance].present? ? app_instance = Thread.current[:appinstance].id : app_instance = 0
-
-          # Separately handling 200 and non 200 as influx does not accept nil as a value
-          if db_runtime && view_runtime
-            # 200 requests
-            begin
-              ZuoraConnect.configuration.telegraf_client.write(ZuoraConnect.configuration.influxdb_series_name_inbound,
-                  tags: {"app_name": "#{ZuoraConnect.configuration.app_name}", "controller": endpoint_name.split("#")[0] , "action": endpoint_name.split("#")[1] , "content-type": content_type, method: method_name, status: status_code, process_type: p_type, "app_instance": app_instance},
-                  values: {response_time: response_time, db_time: db_runtime, view_time: view_runtime})
-            rescue => e
-              raise e
-            end
-          else
-            # non 200 requests
-            begin
-              ZuoraConnect.configuration.telegraf_client.write(ZuoraConnect.configuration.influxdb_series_name_inbound,
-                  tags: {"app_name": "#{ZuoraConnect.configuration.app_name}", "controller": endpoint_name.split("#")[0] , "action": endpoint_name.split("#")[1], "content-type": content_type, method: method_name, status: status_code, process_type: p_type, "app_instance": app_instance},
-                  values: {response_time: response_time})
-            rescue=> e
-              raise e
+    def self.write_to_telegraf(direction: nil, tags: {}, values: {})
+      Rails.logger.tagged("Telegraf") do 
+        time = Benchmark.measure do |bench|
+          # To avoid writing metrics from rspec tests
+          if ENV['DEIS_APP'] || true
+            # Getting the process type
+            p_type = self.get_process_type
+            app_instance = Thread.current[:appinstance].present? ? Thread.current[:appinstance].id : 0
+            tags = tags.merge({ app_name: ZuoraConnect.configuration.app_name, process_type: p_type, app_instance: app_instance})
+
+            if direction == :inbound && ZuoraConnect.configuration.enable_inbound_metrics_flag
+              series = ZuoraConnect.configuration.influxdb_series_name_inbound
+              self.write_metric(series: series, tags: tags, values: values)
+            elsif direction == :outbound && ZuoraConnect.configuration.enable_outbound_metrics_flag
+              series = ZuoraConnect.configuration.influxdb_series_name_outbound
+              self.write_metric(series: series, tags: tags, values: values)
             end
-          end
 
-        elsif direction == "outbound" && ZuoraConnect.configuration.enable_outbound_metrics_flag
-          # if there is an error
-          if error_type
-            begin
-              ZuoraConnect.configuration.telegraf_client.write(ZuoraConnect.configuration.influxdb_series_name_outbound,
-                  tags: {"app_name": "#{ZuoraConnect.configuration.app_name}", endpoint: endpoint_name, status: status_code, process_type: p_type, "app_instance": app_instance, "function_name": function_name, method: method_name, "error_type": error_type},
-                  values: {response_time: response_time})
-            rescue => e
-              raise e
-            end
-          else
-            begin
-              ZuoraConnect.configuration.telegraf_client.write(ZuoraConnect.configuration.influxdb_series_name_outbound,
-                  tags: {"app_name": "#{ZuoraConnect.configuration.app_name}", endpoint: endpoint_name, status: status_code, process_type: p_type, "app_instance": app_instance, "function_name": function_name, method: method_name},
-                  values: {response_time: response_time})
-            rescue => e
-              raise e
-            end
           end
         end
+        if ZuoraConnect.configuration.telegraf_debug
+          Rails.logger.debug(tags.to_s)
+          Rails.logger.debug(values.to_s)
+          Rails.logger.debug("Writing #{direction.capitalize}: #{time.real.round(4)}")
+        end
       end
     end
 
@@ -223,7 +216,6 @@ module ZuoraConnect
 
     def refresh(session = nil)
       refresh_count ||= 0
-      error_type = ""
       start = Time.now
       response = HTTParty.get(ZuoraConnect.configuration.url + "/api/#{self.api_version}/tools/tasks/#{self.id}.json",:body => {:access_token => self.access_token})
       response_time = Time.now - start
@@ -243,7 +235,6 @@ module ZuoraConnect
         Rails.logger.info("[#{self.id}] REFRESH TASK - #{ex.class} Retrying(#{refresh_count})")
         retry
       else
-        error_type = "#{ex.class}"
         Rails.logger.fatal("[#{self.id}] REFRESH TASK - #{ex.class} Failed #{refresh_count}x")
         raise
       end
@@ -255,16 +246,9 @@ module ZuoraConnect
         end
         retry
       else
-        error_type = "#{ex.class}"
         Rails.logger.fatal("[#{self.id}] REFRESH TASK - Failed #{refresh_count}x")
         raise
       end
-    ensure
-      # Writing to telegraf
-      status_code = response.code if response
-      endpoint_name = URI(ZuoraConnect.configuration.url).host
-      Thread.current[:appinstance].present? ? app_instance = Thread.current[:appinstance].id : app_instance = 0
-      ZuoraConnect::AppInstanceBase.write_to_telegraf("response_time": response_time, "status_code": status_code, "endpoint_name": endpoint_name, "direction": "outbound", "error_type": error_type, "function_name": "#{self.class}##{__method__}", "method_name": "GET", "app_instance": app_instance)
     end
 
     #### START Task Mathods ####
@@ -304,28 +288,13 @@ module ZuoraConnect
       end
 
       def updateOption(optionId, value)
-        begin
-          start_time = Time.now
-          response = HTTParty.get(ZuoraConnect.configuration.url + "/api/#{self.api_version}/tools/application_options/#{optionId}/edit?value=#{value}",:body => {:access_token => self.username})
-        rescue => e
-          error_type = "#{e.class}"
-        ensure
-          end_time = Time.now
-          response_time = end_time - start_time
-          status_code = response.code if response
-          endpoint_name = URI(ZuoraConnect.configuration.url).host
-          Thread.current[:appinstance].present? ? app_instance = Thread.current[:appinstance].id : app_instance = 0
-          ZuoraConnect::AppInstanceBase.write_to_telegraf("response_time": response_time, "status_code": status_code, "endpoint_name": endpoint_name, "direction": "outbound", "error_type": error_type, "function_name": "#{self.class}##{__method__}", "method_name": "GET", "app_instance": app_instance)
-          return response
-        end
+        response = HTTParty.get(ZuoraConnect.configuration.url + "/api/#{self.api_version}/tools/application_options/#{optionId}/edit?value=#{value}",:body => {:access_token => self.username})
       end
 
       #This can update an existing login, add a new login, change to another existing login
       #EXAMPLE: {"name": "ftp_login_14","username": "ftplogin7","tenant_type": "Custom","password": "test2","url": "www.ftp.com","custom_data": {  "path": "/var/usr/test"}}
       def update_logins(options)
         update_login_count ||= 0
-        start_time = Time.now
-        error_type = ""
         response = HTTParty.post(ZuoraConnect.configuration.url + "/api/#{self.api_version}/tools/tasks/#{self.id}/logins",:body => {:access_token => self.username}.merge(options))
         parsed_json =  JSON.parse(response.body)
         if response.code == 200
@@ -344,7 +313,6 @@ module ZuoraConnect
         if (update_login_count += 1) < 3
           retry
         else
-          error_type = "#{ex.class}"
           raise
         end
       rescue ZuoraConnect::Exceptions::ConnectCommunicationError => ex
@@ -354,16 +322,8 @@ module ZuoraConnect
           end
           retry
         else
-          error_type = "#{ex.class}"
           raise
         end
-      ensure
-        end_time = Time.now
-        response_time = end_time - start_time
-        status_code = response.code if response
-        endpoint_name = URI(ZuoraConnect.configuration.url).host
-        Thread.current[:appinstance].present? ? app_instance = Thread.current[:appinstance].id : app_instance = 0
-        ZuoraConnect::AppInstanceBase.write_to_telegraf("response_time": response_time, "status_code": status_code, "endpoint_name": endpoint_name, "direction": "outbound", "error_type": error_type, "function_name": "#{self.class}##{__method__}", "method_name": "POST", "app_instance": app_instance)
       end
     #### END Task Mathods ####
 
@@ -382,7 +342,6 @@ module ZuoraConnect
 
       def refresh_oauth
         refresh_oauth_count ||= 0
-        error_type = ""
         start = Time.now
         params = {
                   :grant_type => "refresh_token",
@@ -409,7 +368,6 @@ module ZuoraConnect
           Rails.logger.info("[#{self.id}] REFRESH OAUTH - #{ex.class} Retrying(#{refresh_oauth_count})")
           retry
         else
-          error_type = "#{ex.class}"
           Rails.logger.fatal("[#{self.id}] REFRESH OAUTH - #{ex.class} Failed #{refresh_oauth_count}x")
           raise
         end
@@ -424,15 +382,9 @@ module ZuoraConnect
           Rails.logger.info("[#{self.id}] REFRESH OAUTH - Failed Retrying(#{refresh_oauth_count})")
           retry
         else
-          error_type = "#{ex.class}"
           Rails.logger.fatal("[#{self.id}] REFRESH OAUTH - Failed #{refresh_oauth_count}x")
           raise
         end
-      ensure
-        status_code = response.code if response
-        endpoint_name = URI(ZuoraConnect.configuration.url).host
-        Thread.current[:appinstance].present? ? app_instance = Thread.current[:appinstance].id : app_instance = 0
-        ZuoraConnect::AppInstanceBase.write_to_telegraf("response_time": response_time, "status_code": status_code, "endpoint_name": endpoint_name, "direction": "outbound", "error_type": error_type, "function_name": "#{self.class}##{__method__}", "method_name": "POST", "app_instance": app_instance)
       end
     #### END Connect OAUTH methods ####
 
@@ -479,7 +431,7 @@ module ZuoraConnect
         if defined?(Redis.current)
           #Task data must be present and the last refresh cannot be old. We dont want to overwite new cache data with old
           if self.task_data.present? &&  (self.last_refresh.to_i > INSTANCE_REFRESH_WINDOW.ago.to_i)
-            Rails.logger.info("[#{self.id}] Caching AppInstance")
+            Rails.logger.debug("[#{self.id}] Caching AppInstance")
             Redis.current.setex("AppInstance:#{self.id}", INSTANCE_REDIS_CACHE_PERIOD.to_i, encrypt_data(data: self.save_data))
           end
           Redis.current.del("Deleted:#{self.id}")
@@ -846,6 +798,12 @@ module ZuoraConnect
       return true
     end
 
+    #Method for overiding droping of an app instance
+    def drop_instance
+      self.drop_message = 'Ok to drop'
+      return true
+    end
+
     def reload_attributes(selected_attributes)
       raise "Attibutes must be array" if selected_attributes.class != Array
       value_attributes = self.class.unscoped.where(:id=>id).select(selected_attributes).first.attributes

data/app/models/zuora_connect/login.rb

@@ -4,15 +4,15 @@ module ZuoraConnect
     def initialize (fields)
       @clients = {}
       if fields["tenant_type"] == "Zuora" && fields["entities"] && fields["entities"].size > 0
-        @clients["Default"] = ::ZuoraAPI::Login.new(fields.map{|k,v| [k.to_sym, v]}.to_h)
+        @clients["Default"] = ::ZuoraAPI::Basic.new(fields.map{|k,v| [k.to_sym, v]}.to_h)
         @default_entity = fields["entities"][0]["id"] if fields["entities"].size == 1
         fields["entities"].each do |entity|
           login_fields = fields.map{|k,v| [k.to_sym, v]}.to_h
           login_fields[:entity_id] = entity["id"]
-          @clients[entity["id"]] = ::ZuoraAPI::Login.new(login_fields)
+          @clients[entity["id"]] = ::ZuoraAPI::Basic.new(login_fields)
         end
       elsif fields["tenant_type"] == "Zuora"
-        @clients["Default"] = ::ZuoraAPI::Login.new(fields.map{|k,v| [k.to_sym, v]}.to_h)
+        @clients["Default"] = ::ZuoraAPI::Basic.new(fields.map{|k,v| [k.to_sym, v]}.to_h)
       end
 
       self.attr_builder("available_entities",@clients.keys) if fields["tenant_type"] == "Zuora"

data/config/initializers/postgresql_adapter.rb

@@ -0,0 +1,32 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLAdapter < AbstractAdapter
+      private
+        def load_additional_types(type_map, oids = nil)
+          initializer = OID::TypeMapInitializer.new(type_map)
+          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|
+            initializer.run(records)
+          end
+        end
+    end
+  end
+end

data/lib/metrics/influx/point_value.rb

@@ -0,0 +1,79 @@
+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

data/lib/metrics/net.rb

@@ -0,0 +1,218 @@
+require 'net/http'
+require 'uri'
+require 'set'
+
+# Usage:
+#
+#    require 'http_logger'
+#
+# == Setup logger
+#
+#    HttpLogger.logger = Logger.new('/tmp/all.log')
+#    HttpLogger.log_headers = true
+#
+# == Do request
+#
+#     res = Net::HTTP.start(url.host, url.port) { |http|
+#       http.request(req)
+#     }
+#     ...
+#
+# == View the log
+#
+#     cat /tmp/all.log
+class HttpLogger
+  class << self
+    attr_accessor :collapse_body_limit
+    attr_accessor :log_headers
+    attr_accessor :log_request_body
+    attr_accessor :log_response_body
+    attr_accessor :logger
+    attr_accessor :colorize
+    attr_accessor :ignore
+    attr_accessor :level
+  end
+
+  self.log_headers = false
+  self.log_request_body = true
+  self.log_response_body = true
+  self.colorize = true
+  self.collapse_body_limit = 5000
+  self.ignore = []
+  self.level = :debug
+
+  def self.perform(*args, &block)
+    instance.perform(*args, &block)
+  end
+
+  def self.instance
+    @instance ||= HttpLogger.new
+  end
+
+  def self.deprecate_config(option)
+    warn "Net::HTTP.#{option} is deprecated. Use HttpLogger.#{option} instead."
+  end
+
+  def perform(http, request, request_body)
+    start_time = Time.now
+    tags = {}
+    response = yield
+  rescue => ex
+    tags = tags.merge({error_type: ex.class})
+    raise
+  ensure
+    values = {response_time: ((Time.now - start_time)*1000).round(2)}
+    if require_logging?(http, request)
+      tags = tags.merge({endpoint: http.address, method: request.method})
+      log_request_url(http, request, start_time)
+      log_request_body(request)
+      log_request_headers(request)
+      if defined?(response) && response
+        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)
+    end
+  end
+
+  protected
+
+  def log_request_url(http, request, start_time)
+    ofset = Time.now - start_time
+    log("HTTP #{request.method} (%0.2fms)" % (ofset * 1000), request_url(http, request))
+  end
+
+  def request_url(http, request)
+    URI.decode("http#{"s" if http.use_ssl?}://#{http.address}:#{http.port}#{request.path}")
+  end
+
+  def log_request_headers(request)
+    if self.class.log_headers
+      request.each_capitalized { |k,v| log("HTTP request header", "#{k}: #{v}") }
+    end
+  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)
+        if (body = request.body) && !body.empty?
+          log("Request body", truncate_body(body))
+        end
+      end
+    end
+  end
+
+  def log_response_code(response)
+    log("Response status", "#{response.class} (#{response.code})")
+  end
+
+  def log_response_headers(response)
+    if self.class.log_headers
+      response.each_capitalized { |k,v| log("HTTP response header", "#{k}: #{v}") }
+    end
+  end
+
+  def log_response_body(body)
+    if self.class.log_response_body
+      if body.is_a?(Net::ReadAdapter)
+        log("Response body", "<impossible to log>")
+      else
+        if body && !body.empty?
+          log("Response body", truncate_body(body))
+        end
+      end
+    end
+  end
+
+  def require_logging?(http, request)
+    self.logger && !ignored?(http, request) && (http.started? || fakeweb?(http, request))
+  end
+
+  def ignored?(http, request)
+    url = request_url(http, request)
+    self.class.ignore.any? do |pattern|
+      url =~ pattern
+    end
+  end
+
+  def fakeweb?(http, request)
+    return false unless defined?(::FakeWeb)
+    uri = ::FakeWeb::Utility.request_uri_as_string(http, request)
+    method = request.method.downcase.to_sym
+    ::FakeWeb.registered_uri?(method, uri)
+  end
+
+  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[(body.size - body_piece_size)..body.size]
+    else
+      body
+    end
+  end
+
+  def log(message, dump)
+    self.logger.send(self.class.level, format_log_entry(message, dump)) if Rails.env.to_sym == :development
+  end
+
+  def format_log_entry(message, dump = nil)
+    if self.class.colorize
+      message_color, dump_color = "4;32;1", "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
+      log_entry
+    else
+      "%s  %s" % [message, dump]
+    end
+  end
+
+  def logger
+    self.class.logger
+  end
+
+  def collapse_body_limit
+    self.class.collapse_body_limit
+  end
+end
+
+class Net::HTTP
+
+  def self.log_headers=(value)
+    HttpLogger.deprecate_config("log_headers")
+    HttpLogger.log_headers = value
+  end
+
+  def self.colorize=(value)
+    HttpLogger.deprecate_config("colorize")
+    HttpLogger.colorize = value
+  end
+
+  def self.logger=(value)
+    HttpLogger.deprecate_config("logger")
+    HttpLogger.logger = value
+  end
+
+
+  alias_method :request_without_logging,  :request
+
+  def request(request, body = nil, &block)
+    HttpLogger.perform(self, request, body) do
+      request_without_logging(request, body, &block) 
+    end
+  end
+end
+
+if defined?(Rails)
+  if defined?(ActiveSupport) && ActiveSupport.respond_to?(:on_load)
+    # Rails3
+    ActiveSupport.on_load(:after_initialize) do
+      HttpLogger.logger = Rails.logger unless HttpLogger.logger
+    end
+  end
+end

data/lib/middleware/metrics_middleware.rb

@@ -6,38 +6,37 @@ module Middleware
 
     # This method is triggered when a non error page is loaded (not 404)
     def call(name, started, finished, unique_id, payload)
-
       if ZuoraConnect.configuration.enable_inbound_metrics_flag == true
-
         # If the url contains any css or JavaScript files then do not collect metrics for them
-        block_words = ["css", "assets", "jpg", "png", "jpeg", "ico"]
-        if block_words.any? { |word| payload[:path].include?(word) }
-          return nil
-        end
+        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"}
-        content_hash.key?(payload[:format]) ? content_type = content_hash[payload[:format]] : content_type = payload[:format]
-        request_path = "#{payload[:controller]}##{payload[:action]}"
-        response_time = finished-started
+        content_type = content_hash.key?(payload[:format]) ? content_hash[payload[:format]] : payload[:format]
 
         # 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 : ""
+        #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
 
-        # Write to telegraf
-        ZuoraConnect::AppInstanceBase.write_to_telegraf("endpoint_name": request_path, "method_name": payload[:method], "status_code": status_code, "response_time": response_time, "db_runtime": payload[:db_runtime].to_f, "view_runtime": payload[:view_runtime], "content_type": content_type, "direction": "inbound")
+        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
   end
 
-
   class MetricsMiddleware
 
     require "zuora_connect/version"
     require "zuora_api/version"
-    require "telegraf"
 
     def initialize(app)
       @app = app
@@ -46,15 +45,10 @@ module Middleware
     def call(env)
       start_time = Time.now
       @status, @headers, @response = @app.call(env)
-      end_time = Time.now
+
       if ZuoraConnect.configuration.enable_inbound_metrics_flag == true
         # If the url contains any CSS or JavaScript files then do not collect metrics for them
-        block_words = ["css", "assets", "jpg", "png", "jpeg", "ico"]
-        if block_words.any? { |word| env['PATH_INFO'].include?(word) }
-          return [@status, @headers, @response]
-        end
-
-        response_time = end_time - start_time
+        return [@status, @headers, @response] if ["css", "assets", "jpg", "png", "jpeg", "ico"].any? { |word| env['PATH_INFO'].include?(word) }
 
         if defined? Prometheus
           #Prometheus Stuff
@@ -86,28 +80,30 @@ module Middleware
 
           end
         end
-        # Writing to telegraf: Handle 404 and 500 requests
-        if @status == 404 || @status == 304
-          # Getting the endpoint and content_type
-          request_path = @status == 404 ? "ActionController#RoutingError" : env["action_controller.instance"].present? ? "#{env["action_controller.instance"].class}##{env["action_controller.instance"].action_name}" : ""
-
-          # Uncomment following block of code for handling engine requests/requests without controller
-          # else
-          #   # Handling requests which do not have controllers (engines)
-          #   if env["SCRIPT_NAME"].present?
-          #     controller_path = "#{env['SCRIPT_NAME'][1..-1]}"
-          #     controller_path = controller_path.sub("/", "::")
-          #     request_path = "#{controller_path}#UnknownAction"
-          #   end
-
-          content_type = @headers['Content-Type'].split(';')[0] if @headers['Content-Type']
-          ZuoraConnect::AppInstanceBase.write_to_telegraf("endpoint_name": request_path, "method_name": env['REQUEST_METHOD'], "status_code": @status, "response_time": response_time,  "content_type": content_type, "direction": "inbound") if request_path.present?
+
+        # Uncomment following block of code for handling engine requests/requests without controller
+        # else
+        #   # Handling requests which do not have controllers (engines)
+        if env["SCRIPT_NAME"].present?
+          controller_path = "#{env['SCRIPT_NAME'][1..-1]}"
+          controller_path = controller_path.sub("/", "::")
+          request_path = "#{controller_path}#UnknownAction"
+        else
+          # Writing to telegraf: Handle 404
+          if [404].include?(@status)
+            content_type = @headers['Content-Type'].split(';')[0] if @headers['Content-Type']
+
+            tags = {status: @status, content_type: content_type}
+         
+            tags = tags.merge({controller: 'ActionController', action: 'RoutingError' })
+            
+            values = {response_time: ((Time.now - start_time)*1000).round(2) }
+
+            ZuoraConnect::AppInstanceBase.write_to_telegraf(direction: :inbound, tags: tags, values: values)
+          end
         end
       end
       [@status, @headers, @response]
-
     end
-
   end
-
 end

data/lib/zuora_connect/configuration.rb

@@ -1,6 +1,13 @@
 module ZuoraConnect
   class Configuration
-    attr_accessor :oauth_client_id, :oauth_client_secret, :oauth_client_redirect_uri,:use_s3, :default_locale,:dev_mode_appinstance ,:dev_mode_admin, :dev_mode_user, :dev_mode_pass, :default_time_zone,:delayed_job,:url, :private_key, :dev_mode_logins,:dev_mode_mode, :dev_mode_options, :mode, :timeout,:dev_mode_secret_access_key,:dev_mode_access_key_id,:aws_region, :s3_bucket_name, :s3_folder_name, :additional_apartment_models, :telegraf_endpoint, :enable_inbound_metrics_flag, :enable_outbound_metrics_flag, :telegraf_client, :custom_prometheus_update_block, :app_name, :influxdb_series_name_inbound, :influxdb_series_name_outbound
+
+    attr_accessor :default_locale, :default_time_zone, :url, :mode, :delayed_job,:private_key, :additional_apartment_models
+
+    attr_accessor :telegraf_endpoint, :telegraf_debug, :enable_inbound_metrics_flag, :enable_outbound_metrics_flag, :custom_prometheus_update_block, :app_name, :influxdb_series_name_inbound, :influxdb_series_name_outbound
+
+    attr_accessor :oauth_client_id, :oauth_client_secret, :oauth_client_redirect_uri
+
+    attr_accessor :dev_mode_logins, :dev_mode_options, :dev_mode_mode, :dev_mode_appinstance, :dev_mode_user, :dev_mode_pass, :dev_mode_admin, :dev_mode_secret_access_key,:dev_mode_access_key_id,:aws_region, :s3_bucket_name, :s3_folder_name
 
     def initialize
       @default_locale = :en
@@ -8,19 +15,20 @@ module ZuoraConnect
       @url = "https://connect.zuora.com"
       @mode = "Production"
       @delayed_job = false
-      @use_s3 = false
       @private_key = ENV["CONNECT_KEY"]
       @additional_apartment_models = []
+      
+
+      # Setting the app name for telegraf write
       @telegraf_endpoint = 'udp://telegraf-app-metrics.monitoring.svc.cluster.local:8094'
+      @telegraf_debug = false
       @enable_inbound_metrics_flag =  false
       @enable_outbound_metrics_flag =  false
-      @telegraf_client = Telegraf::Agent.new @telegraf_endpoint
-
-      # Setting the app name for telegraf write
-      @app_name = ENV['DEIS_APP'].present? ? "#{ENV['DEIS_APP']}" : "#{Rails.application.class.parent_name}"
       @influxdb_series_name_inbound = "request-inbound"
       @influxdb_series_name_outbound = "request-outbound"
 
+      @app_name = ENV['DEIS_APP'].present? ? "#{ENV['DEIS_APP']}" : "#{Rails.application.class.parent_name}"
+      
       # OAuth Settings
       @oauth_client_id = ""
       @oauth_client_secret = ""

data/lib/zuora_connect/controllers/helpers.rb

@@ -21,7 +21,7 @@ module ZuoraConnect
             check_instance
           end
         end
-        Rails.logger.info("[#{@appinstance.blank? ? "N/A" : @appinstance.id}] Authenticate App API Request Completed In - #{(Time.now - start_time).round(2)}s")
+        Rails.logger.debug("[#{@appinstance.blank? ? "N/A" : @appinstance.id}] Authenticate App API Request Completed In - #{(Time.now - start_time).round(2)}s")
       end
 
       def authenticate_connect_app_request

data/lib/zuora_connect/version.rb

@@ -1,3 +1,3 @@
 module ZuoraConnect
-    VERSION = "1.6.05"
+    VERSION = "1.6.06"
 end

data/lib/zuora_connect.rb

@@ -7,7 +7,8 @@ require 'zuora_connect/railtie'
 require 'resque/additions'
 require 'resque/dynamic_queues'
 require 'resque/self_lookup'
-
+require 'metrics/influx/point_value'
+require 'metrics/net'
 
 module ZuoraConnect
   class << self

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zuora_connect
 version: !ruby/object:Gem::Version
-  version: 1.6.05
+  version: 1.6.06
 platform: ruby
 authors:
 - Connect Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-08-24 00:00:00.000000000 Z
+date: 2018-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: apartment
@@ -36,20 +36,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.5.0
+        version: 1.6.0
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.4.0
+        version: 1.6.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.5.0
+        version: 1.6.0
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.4.0
+        version: 1.6.0
 - !ruby/object:Gem::Dependency
   name: httparty
   requirement: !ruby/object:Gem::Requirement
@@ -106,20 +106,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: telegraf
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.4.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.4.0
 - !ruby/object:Gem::Dependency
   name: railties
   requirement: !ruby/object:Gem::Requirement
@@ -252,6 +238,7 @@ files:
 - app/views/zuora_connect/static/session_error.html.erb
 - config/initializers/apartment.rb
 - config/initializers/object_method_hooks.rb
+- config/initializers/postgresql_adapter.rb
 - config/initializers/prometheus.rb
 - config/initializers/redis.rb
 - config/initializers/resque.rb
@@ -267,6 +254,8 @@ files:
 - db/migrate/20110503003603_add_catalog_mappings_to_app_instance.rb
 - db/migrate/20110503003604_catalog_default.rb
 - db/migrate/20180301052853_add_catalog_attempted_at.rb
+- lib/metrics/influx/point_value.rb
+- lib/metrics/net.rb
 - lib/middleware/metrics_middleware.rb
 - lib/resque/additions.rb
 - lib/resque/dynamic_queues.rb