zuora_connect 0

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

@@ -0,0 +1,134 @@
+module Middleware
+  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"
+    require "zuora_api/version"
+
+    def initialize(app)
+      @app = app
+    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"] 
+      if !ActionDispatch::Request::HTTP_METHODS.include?(env["REQUEST_METHOD"].upcase)
+        [405, {"Content-Type" => "text/plain"}, ["Method Not Allowed"]]
+      else
+        if (env['HTTP_ZUORA_LAYOUT_FETCH_TEMPLATE_ID'].present?)
+          Thread.current[:isHallway] = "/#{env['HTTP_ZUORA_LAYOUT_FETCH_TEMPLATE_ID']}"
+          env['PATH_INFO'] = env['PATH_INFO'].gsub(Thread.current[:isHallway], '')
+          env['REQUEST_URI'] = env['REQUEST_URI'].gsub(Thread.current[:isHallway], '')
+          env['REQUEST_PATH'] = env['REQUEST_PATH'].gsub(Thread.current[:isHallway], '')
+
+          #We need the forwarded host header to identify location of tenant
+          @bad_headers.delete('HTTP_X_FORWARDED_HOST')
+        else
+          Thread.current[:isHallway] = nil
+        end
+
+        #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])
+
+                rescue Redis::CannotConnectError
+                    Prometheus::REDIS_CONNECTION.set({connection:'redis',name: ZuoraConnect::Telegraf.app_name},0)
+                end
+
+                if ZuoraConnect.configuration.custom_prometheus_update_block != nil
+                  ZuoraConnect.configuration.custom_prometheus_update_block.call()
+                end
+              end
+
+            end
+          end
+
+          # Uncomment following block of code for handling engine requests/requests without controller
+          # else
+          #   # Handling requests which do not have controllers (engines)
+          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, 500].include?(@status)
+              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)
+            end
+          end
+          Thread.current[:inbound_metric] = nil
+        end
+        [@status, @headers, @response]
+      end
+    end
+  end
+end

data/lib/resque/additions.rb

@@ -0,0 +1,53 @@
+module Resque
+  module Additions
+    def dequeue_from(queue, klass, *args)
+      ####### ------ Resque Job --------
+      # Perform before_dequeue hooks. Don't perform dequeue if any hook returns false
+      before_hooks = Plugin.before_dequeue_hooks(klass).collect do |hook|
+        klass.send(hook, *args)
+      end
+      return if before_hooks.any? { |result| result == false }
+
+      destroyed = Job.destroy(queue, klass, *args)
+
+      Plugin.after_dequeue_hooks(klass).each do |hook|
+        klass.send(hook, *args)
+      end
+
+      destroyed
+    end
+    
+    ####### ------ Resque Delayed Job --------
+    # Returns delayed jobs schedule timestamp for +klass+, +args+.
+    def scheduled_at_with_queue(queue, klass, *args)
+      search = encode(job_to_hash_with_queue(queue,klass, args))
+      redis.smembers("timestamps:#{search}").map do |key|
+        key.tr('delayed:', '').to_i
+      end
+    end
+
+    # Given an encoded item, remove it from the delayed_queue
+    def remove_delayed_with_queue(queue, klass, *args)
+      search = encode(job_to_hash_with_queue(queue,klass, args))
+      remove_delayed_job(search)
+    end
+
+    #Given a timestamp and job (klass + args) it removes all instances and
+    # returns the count of jobs removed.
+    #
+    # O(N) where N is the number of jobs scheduled to fire at the given
+    # timestamp
+    def remove_delayed_job_with_queue_from_timestamp(timestamp, queue, klass, *args)
+      return 0 if Resque.inline?
+
+      key = "delayed:#{timestamp.to_i}"
+      encoded_job = encode(job_to_hash_with_queue(queue, klass, args))
+
+      redis.srem("timestamps:#{encoded_job}", key)
+      count = redis.lrem(key, 0, encoded_job)
+      clean_up_timestamp(key, timestamp)
+
+      count
+    end
+  end
+end

data/lib/resque/dynamic_queues.rb

@@ -0,0 +1,222 @@
+module Resque
+  module DynamicQueues
+    def filter_busy_queues qs
+      busy_queues = Resque::Worker.working.map { |worker| worker.job["queue"] }.compact
+      Array(qs.dup).compact - busy_queues
+    end
+
+    def rotated_queues
+      @n ||= 0
+      @n += 1
+      rot_queues = queues # since we rely on the resque-dynamic-queues plugin, this is all the queues, expanded out
+      if rot_queues.size > 0
+        @n = @n % rot_queues.size
+        rot_queues.rotate(@n)
+      else
+        rot_queues
+      end
+    end
+
+    def queue_depth queuename
+      busy_queues = Resque::Worker.working.map { |worker| worker.job["queue"] }.compact
+      # find the queuename, count it.
+      busy_queues.select {|q| q == queuename }.size
+    end
+
+    def get_categorized_queues(queue_list)
+      priority_map = {"Synchronous" => 0, "High" => 1, "Medium" => 2, "Low" => 3}
+      categorized_queues = {}
+      for queue in queue_list.uniq
+        priority = queue.split("_")[1]
+        priority = "Medium" if !["Synchronous", "High", "Medium", "Low"].include?(priority)
+        categorized_queues[priority] ||= []
+        categorized_queues[priority].push(queue)
+      end
+      return categorized_queues.transform_keys{ |key| priority_map[key.to_s]}.sort
+    end
+
+    DEFAULT_QUEUE_DEPTH = 0
+    def should_work_on_queue? queuename
+      return true if @queues.include? '*'  # workers with QUEUES=* are special and are not subject to queue depth setting
+      max = DEFAULT_QUEUE_DEPTH
+      unless ENV["RESQUE_QUEUE_DEPTH"].nil? || ENV["RESQUE_QUEUE_DEPTH"] == ""
+        max = ENV["RESQUE_QUEUE_DEPTH"].to_i
+      end
+      return true if max == 0 # 0 means no limiting
+      cur_depth = queue_depth(queuename)
+      log! "queue #{queuename} depth = #{cur_depth} max = #{max}"
+      return true if cur_depth < max
+      false
+    end
+
+    def get_grouped_queues
+      self.queues.sort.group_by{|u| /(\d{1,20})_.*/.match(u) ? /(\d{1,20})_.*/.match(u).captures.first : nil}
+    end
+
+    def reserve_with_round_robin
+      grouped_queues = self.get_grouped_queues
+
+      #Instance queue grouping
+      if !grouped_queues.keys.include?(nil) && grouped_queues.keys.size > 0
+        if ZuoraConnect.configuration.blpop_queue
+          @job_in_progress = get_restricted_job
+          return @job_in_progress if @job_in_progress.present?
+          return @job_in_progress = get_queued_job(grouped_queues)
+        else
+          @n ||= 0       
+          @n += 1
+          @n = @n % grouped_queues.keys.size
+          grouped_queues.keys.rotate(@n).each do |key|
+            self.get_categorized_queues(grouped_queues[key]).each do |key, queues|
+              queues.each do |queue|
+                log! "Checking #{queue}"
+                if should_work_on_queue?(queue) && @job_in_progress = Resque::Job.reserve(queue)
+                  log! "Found job on #{queue}"
+                  return @job_in_progress
+                end
+              end
+            end
+            @n += 1 # Start the next search at the queue after the one from which we pick a job.
+          end
+          nil
+        end
+      else 
+        return reserve_without_round_robin
+      end
+      
+    rescue Exception => e
+      log "Error reserving job: #{e.inspect}"
+      log e.backtrace.join("\n")
+      raise e
+    end
+
+    def create_job(queue, payload)
+      return unless payload
+      Resque::Job.new(queue, payload)
+    end
+
+    def get_next_job(grouped_queues)
+      @n ||= 1
+      queue_index = {}
+      grouped_queues.each_with_index do |(key, queue_list), index|
+        queue_list.each do |queue|
+          queue_index[queue] = index
+        end
+      end
+
+      grouped_queues = grouped_queues.values.rotate(@n).map{|queue_list| get_categorized_queues(queue_list).to_h.values.flatten}.flatten.delete_if{|queue| !should_work_on_queue?(queue)}.map{|queue| "queue:#{queue}"}
+      queue, payload = Resque.redis.blpop(grouped_queues, :timeout => (ENV["BLPOP_TIMEOUT"].to_i || 30))
+      return nil if queue.blank?
+      
+      queue = queue.split("queue:")[1]
+      @n = queue_index[queue] + 1
+      return create_job(queue, Resque.decode(payload))      
+    end
+
+    def get_restricted_job
+      Resque::Plugins::ConcurrentRestrictionJob.next_runnable_job_random
+    end
+
+    def get_queued_job(grouped_queues)
+      if defined?(Resque::Plugins::ConcurrentRestriction)
+        # Bounded retry
+        1.upto(Resque::Plugins::ConcurrentRestriction.reserve_queued_job_attempts) do |i|
+          resque_job = get_next_job(grouped_queues)
+
+          # Short-curcuit if a job was not found
+          return if resque_job.nil?
+
+          # If there is a job on regular queues, then only run it if its not restricted
+          job_class = resque_job.payload_class
+          job_args = resque_job.args
+
+          # Return to work on job if not a restricted job
+          return resque_job unless job_class.is_a?(Resque::Plugins::ConcurrentRestriction)
+
+          # Keep trying if job is restricted. If job is runnable, we keep the lock until
+          # done_working
+          return resque_job unless job_class.stash_if_restricted(resque_job)
+        end
+        
+        # Safety net, here in case we hit the upper bound and there are still queued items
+        return nil        
+      else
+        return get_next_job(grouped_queues)
+      end
+    end
+
+    # Returns a list of queues to use when searching for a job.
+    #
+    # A splat ("*") means you want every queue (in alpha order) - this
+    # can be useful for dynamically adding new queues.
+    #
+    # The splat can also be used as a wildcard within a queue name,
+    # e.g. "*high*", and negation can be indicated with a prefix of "!"
+    #
+    # An @key can be used to dynamically look up the queue list for key from redis.
+    # If no key is supplied, it defaults to the worker's hostname, and wildcards
+    # and negations can be used inside this dynamic queue list.   Set the queue
+    # list for a key with Resque.set_dynamic_queue(key, ["q1", "q2"]
+    #
+    def queues_with_dynamic
+      queue_names = @queues.dup
+      
+      return queues_without_dynamic if queue_names.grep(/(^!)|(^@)|(\*)/).size == 0
+
+      real_queues = Resque.queues
+      matched_queues = []
+
+      #Remove Queues under Api Limits
+      Redis.current.zremrangebyscore("APILimits", "0", "(#{Time.now.to_i}")
+      api_limit_instances = Redis.current.zrange("APILimits", 0, -1).map {|key| key.to_i if key.match(/^\d*$/)}.compact
+      real_queues = real_queues.select {|key| key if !api_limit_instances.include?((key.match(/^(\d*)_.*/) || [])[1].to_i)} ## 2
+        
+      #Queue Pausing 
+      Resque.redis.zremrangebyscore("PauseQueue", "0", "(#{Time.now.to_i}")
+      paused_instances = Resque.redis.zrange("PauseQueue", 0, -1).map {|key| key.split("__")[0].to_i if key.match(/^\d*__.*/)}.compact
+      real_queues = real_queues.select {|key| key if !paused_instances.include?((key.match(/^(\d*)_.*/) || [])[1].to_i)}
+
+      while q = queue_names.shift
+        q = q.to_s
+
+        if q =~ /^(!)?@(.*)/
+          key = $2.strip
+          key = hostname if key.size == 0
+
+          add_queues = Resque.get_dynamic_queue(key)
+          add_queues.map! { |q| q.gsub!(/^!/, '') || q.gsub!(/^/, '!') } if $1
+
+          queue_names.concat(add_queues)
+          next
+        end
+
+        if q =~ /^!/
+          negated = true
+          q = q[1..-1]
+        end
+
+        patstr = q.gsub(/\*/, '.*')
+        pattern = /^#{patstr}$/
+        if negated
+          matched_queues -= matched_queues.grep(pattern)
+        else
+          matches = real_queues.grep(/^#{pattern}$/)
+          matches = [q] if matches.size == 0 && q == patstr
+          matched_queues.concat(matches.sort)
+        end
+      end
+     
+      return matched_queues.uniq
+    end
+
+
+    def self.included(receiver)
+      receiver.class_eval do
+        alias queues_without_dynamic queues
+        alias queues queues_with_dynamic
+        alias reserve_without_round_robin reserve
+        alias reserve reserve_with_round_robin
+      end
+    end
+  end
+end