zuora_connectD 1.7.09

data/config/initializers/object_method_hooks.rb

@@ -0,0 +1,27 @@
+class Object
+  def self.method_hook(*args)
+    options = args.extract_options!
+    return unless (options[:before].present? or options[:after].present?)
+    args.each do |method_name|      
+      old_method = instance_method(method_name) rescue next
+
+      define_method(method_name) do |*args|
+        # invoke before callback
+        if options[:before].present?
+          options[:before].is_a?(Proc) ? options[:before].call(method_name, self):
+            send(options[:before], method_name) 
+        end
+
+        # you can modify the code to call after callback 
+        # only when the old method returns true etc..
+        old_method.bind(self).call(*args)
+
+        # invoke after callback
+        if options[:after].present?
+          options[:after].is_a?(Proc) ? options[:after].call(method_name, self): 
+            send(options[:after], method_name) 
+        end
+      end
+    end
+  end
+end

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/config/initializers/prometheus.rb

@@ -0,0 +1,41 @@
+if defined? Prometheus
+  module Prometheus
+    require "zuora_connectD/version"
+    require "zuora_api/version"
+
+    app_name = ENV['DEIS_APP'].present? ? "#{ENV['DEIS_APP']}" : "#{Rails.application.class.parent_name}"
+    # Create a default Prometheus registry for our metrics.
+    prometheus = Prometheus::Client.registry
+
+    # Create your metrics.
+    ZUORA_VERSION = Prometheus::Client::Gauge.new(:zuora_version, 'The current Zuora Gem version.')
+    CONNECT_VERSION = Prometheus::Client::Gauge.new(:gem_version, 'The current Connect Gem version.')
+    RAILS_VERSION = Prometheus::Client::Gauge.new(:rails_version, 'The current Rails version.')
+    RUBY_V = Prometheus::Client::Gauge.new(:ruby_version, 'The current Ruby version.')
+
+    # Register your metrics with the registry we previously created.
+    prometheus.register(ZUORA_VERSION);ZUORA_VERSION.set({version:ZuoraAPI::VERSION,name:app_name},0)
+    prometheus.register(CONNECT_VERSION);CONNECT_VERSION.set({version:ZuoraConnect::VERSION,name:app_name},0)
+    prometheus.register(RAILS_VERSION);RAILS_VERSION.set({version:Rails.version,name:app_name},0)
+    prometheus.register(RUBY_V);RUBY_V.set({version:RUBY_VERSION,name:app_name},0)
+
+    # Do they have resque jobs?
+    if defined? Resque.redis
+      REDIS_CONNECTION = Prometheus::Client::Gauge.new(:redis_connection, 'The status of the redis connection, 0 or 1')
+      FINISHED_JOBS = Prometheus::Client::Gauge.new(:finished_jobs, 'Done resque jobs')
+      WORKERS = Prometheus::Client::Gauge.new(:workers, 'Total resque workers')
+      ACTIVE_WORKERS = Prometheus::Client::Gauge.new(:active_workers, 'Active resque workers')
+      FAILED_JOBS = Prometheus::Client::Gauge.new(:failed_jobs, 'Failed resque jobs')
+      PENDING_JOBS = Prometheus::Client::Gauge.new(:pending_jobs, 'Pending resque jobs')
+
+      prometheus.register(REDIS_CONNECTION)
+      prometheus.register(FINISHED_JOBS)
+      prometheus.register(ACTIVE_WORKERS)
+      prometheus.register(WORKERS)
+      prometheus.register(FAILED_JOBS)
+      prometheus.register(PENDING_JOBS)
+
+    end
+
+  end
+end

data/config/initializers/redis.rb

@@ -0,0 +1,10 @@
+redis_url = ENV["REDIS_URL"].present? ?  ENV["REDIS_URL"] : defined?(Rails.application.secrets.redis) ? Rails.application.secrets.redis : 'redis://localhost:6379/1'
+if defined?(Redis.current)
+  Redis.current = Redis.new(:url => redis_url, :timeout => 10, :reconnect_attempts => 2)
+  if defined?(Resque.redis)
+    Resque.redis = Redis.current
+  end
+end
+if defined?(RedisBrowser)
+  RedisBrowser.configure("connections" => { "default" => { "url" => redis_url } })
+end

data/config/initializers/resque.rb

@@ -0,0 +1,6 @@
+if defined?(Resque::Worker)
+  Resque.send(:extend, Resque::Additions)
+  Resque::Worker.send(:include, Resque::DynamicQueues)
+  Resque::Worker.send(:include, Resque::SilenceDone) if ZuoraConnect.configuration.silencer_resque_finish == true
+  Resque::Job.send(:include, Resque::SelfLookup)
+end

data/config/initializers/to_bool.rb

@@ -0,0 +1,24 @@
+class String
+  def to_bool
+    return self if (self.class == TrueClass || self.class == FalseClass)
+    return true   if self == true   || self =~ (/(true|t|yes|y|1)$/i)
+    return false  if self == false  || self.blank? || self =~ (/(false|f|no|n|0)$/i)
+    return false
+    raise ArgumentError.new("invalid value for Boolean: \"#{self}\"")
+  end
+end
+class TrueClass
+  def to_bool
+    return self 
+  end
+end
+class FalseClass
+  def to_bool
+    return self 
+  end
+end
+class NilClass
+  def to_bool
+    return false 
+  end
+end

data/config/initializers/unicorn.rb

@@ -0,0 +1,9 @@
+if defined?(Unicorn::WorkerKiller)
+  Unicorn::WorkerKiller.module_eval do
+    self.singleton_class.send(:alias_method, :kill_self_old, :kill_self)
+    def self.kill_self(logger, start_time)
+      self.kill_self_old(logger, start_time)
+      ZuoraConnect::AppInstance.write_to_telegraf(direction: 'Unicorn-Killer', tags: {app_instance: 0}, values: {kill: 1})
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,13 @@
+ZuoraConnect::Engine.routes.draw do
+  get '/health' => 'static#health'
+  get '/internal/data' => 'static#metrics'
+  get '/invalid_session' => 'static#session_error', :as => :invalid_session
+  get '/invalid_instance' => "static#invalid_app_instance_error", :as => :invalid_instance
+  namespace :api do
+    namespace :v1 do
+      resources :app_instance, :only => [:index], defaults: {format: :json} do
+          match "drop", via: [:get, :post], on: :collection
+      end
+    end
+  end
+end

data/db/migrate/20100718151733_create_connect_app_instances.rb

@@ -0,0 +1,9 @@
+class CreateConnectAppInstances < ActiveRecord::Migration
+  def change
+    if !ActiveRecord::Base.connection.table_exists?('zuora_connect_app_instances')
+      create_table :zuora_connect_app_instances do |t|
+        t.timestamps null: false
+      end
+    end
+  end
+end

data/db/migrate/20101024162319_add_tokens_to_app_instance.rb

@@ -0,0 +1,6 @@
+class AddTokensToAppInstance < ActiveRecord::Migration
+  def change
+    add_column :zuora_connect_app_instances, :access_token, :string unless column_exists? :zuora_connect_app_instances, :access_token
+    add_column :zuora_connect_app_instances, :refresh_token, :string unless column_exists? :zuora_connect_app_instances, :refresh_token
+  end
+end

data/db/migrate/20101024220705_add_token_to_app_instance.rb

@@ -0,0 +1,5 @@
+class AddTokenToAppInstance < ActiveRecord::Migration
+  def change
+    add_column :zuora_connect_app_instances, :token, :string  unless column_exists? :zuora_connect_app_instances, :token
+  end
+end

data/db/migrate/20110131211919_add_sessions_table.rb

@@ -0,0 +1,13 @@
+class AddSessionsTable < ActiveRecord::Migration
+  def change
+    if !ActiveRecord::Base.connection.table_exists?('sessions')
+      create_table :sessions do |t|
+        t.string :session_id, :null => false
+        t.text :data
+        t.timestamps
+      end
+      add_index :sessions, :session_id, :unique => true
+      add_index :sessions, :updated_at
+    end
+  end
+end

data/db/migrate/20110411200303_add_expiration_to_app_instance.rb

@@ -0,0 +1,5 @@
+class AddExpirationToAppInstance < ActiveRecord::Migration
+  def change
+    add_column :zuora_connect_app_instances, :oauth_expires_at, :datetime  unless column_exists? :zuora_connect_app_instances, :oauth_expires_at
+  end
+end

data/db/migrate/20110413191512_add_new_api_token.rb

@@ -0,0 +1,5 @@
+class AddNewApiToken < ActiveRecord::Migration
+  def change
+    add_column :zuora_connect_app_instances, :api_token, :string  unless column_exists? :zuora_connect_app_instances, :api_token
+  end
+end

data/db/migrate/20110503003602_add_catalog_data_to_app_instance.rb

@@ -0,0 +1,6 @@
+class AddCatalogDataToAppInstance < ActiveRecord::Migration
+  def change
+    add_column :zuora_connect_app_instances, :catalog_updated_at, :datetime  unless column_exists? :zuora_connect_app_instances, :catalog_updated_at
+    add_column :zuora_connect_app_instances, :catalog, :jsonb, default: {}  unless column_exists? :zuora_connect_app_instances, :catalog
+  end
+end

data/db/migrate/20110503003603_add_catalog_mappings_to_app_instance.rb

@@ -0,0 +1,5 @@
+class AddCatalogMappingsToAppInstance < ActiveRecord::Migration
+  def change
+    add_column :zuora_connect_app_instances, :catalog_mapping, :jsonb, default: {} unless column_exists? :zuora_connect_app_instances, :catalog_mapping
+  end
+end

data/db/migrate/20110503003604_catalog_default.rb

@@ -0,0 +1,5 @@
+class CatalogDefault < ActiveRecord::Migration
+  def change
+    change_column :zuora_connect_app_instances, :catalog, :jsonb, default: {}
+  end
+end

data/db/migrate/20180301052853_add_catalog_attempted_at.rb

@@ -0,0 +1,5 @@
+class AddCatalogAttemptedAt < ActiveRecord::Migration
+  def change
+    add_column :zuora_connect_app_instances, :catalog_update_attempt_at, :datetime  unless column_exists? :zuora_connect_app_instances, :catalog_update_attempt_at
+  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