zuora_connect 0

data/config/initializers/apartment.rb

@@ -0,0 +1,95 @@
+# You can have Apartment route to the appropriate Tenant by adding some Rack middleware.
+# Apartment can support many different "Elevators" that can take care of this routing to your data.
+# Require whichever Elevator you're using below or none if you have a custom one.
+#
+# require 'apartment/elevators/generic'
+# require 'apartment/elevators/domain'
+#require 'apartment/elevators/subdomain'
+# require 'apartment/elevators/first_subdomain'
+#
+# Apartment Configuration
+#
+Apartment.configure do |config|
+
+  # Add any models that you do not want to be multi-tenanted, but remain in the global (public) namespace.
+  # A typical example would be a Customer or Tenant model that stores each Tenant's information.
+  #
+  # config.excluded_models = %w{ Tenant }
+
+  # In order to migrate all of your Tenants you need to provide a list of Tenant names to Apartment.
+  # You can make this dynamic by providing a Proc object to be called on migrations.
+  # This object should yield either:
+  # - an array of strings representing each Tenant name.
+  # - a hash which keys are tenant names, and values custom db config (must contain all key/values required in database.yml)
+  #
+  # config.tenant_names = lambda{ Customer.pluck(:tenant_name) }
+  # config.tenant_names = ['tenant1', 'tenant2']
+  # config.tenant_names = {
+  #   'tenant1' => {
+  #     adapter: 'postgresql',
+  #     host: 'some_server',
+  #     port: 5555,
+  #     database: 'postgres' # this is not the name of the tenant's db
+  #                          # but the name of the database to connect to before creating the tenant's db
+  #                          # mandatory in postgresql
+  #   },
+  #   'tenant2' => {
+  #     adapter:  'postgresql',
+  #     database: 'postgres' # this is not the name of the tenant's db
+  #                          # but the name of the database to connect to before creating the tenant's db
+  #                          # mandatory in postgresql
+  #   }
+  # }
+  # config.tenant_names = lambda do
+  #   Tenant.all.each_with_object({}) do |tenant, hash|
+  #     hash[tenant.name] = tenant.db_configuration
+  #   end
+  # end
+  #
+  config.tenant_names = lambda { ZuoraConnect::AppInstance.pluck :id }
+  if defined?(ActiveRecord::SessionStore::Session)
+    config.excluded_models = ["ZuoraConnect::AppInstance","ZuoraConnect::AppInstanceBase", "ActiveRecord::SessionStore::Session"]
+  else
+    config.excluded_models = ["ZuoraConnect::AppInstance","ZuoraConnect::AppInstanceBase"]
+  end
+  #
+  # ==> PostgreSQL only options
+
+  # Specifies whether to use PostgreSQL schemas or create a new database per Tenant.
+  # The default behaviour is true.
+  #
+  config.use_schemas = true
+
+  # Apartment can be forced to use raw SQL dumps instead of schema.rb for creating new schemas.
+  # Use this when you are using some extra features in PostgreSQL that can't be respresented in
+  # schema.rb, like materialized views etc. (only applies with use_schemas set to true).
+  # (Note: this option doesn't use db/structure.sql, it creates SQL dump by executing pg_dump)
+  #
+  # config.use_sql = false
+
+  # There are cases where you might want some schemas to always be in your search_path
+  # e.g when using a PostgreSQL extension like hstore.
+  # Any schemas added here will be available along with your selected Tenant.
+  #
+  config.persistent_schemas = %w{ shared_extensions }
+
+  # <== PostgreSQL only options
+  #
+
+  # By default, and only when not using PostgreSQL schemas, Apartment will prepend the environment
+  # to the tenant name to ensure there is no conflict between your environments.
+  # This is mainly for the benefit of your development and test environments.
+  # Uncomment the line below if you want to disable this behaviour in production.
+  #
+  # config.prepend_environment = !Rails.env.production?
+end
+
+# Setup a custom Tenant switching middleware. The Proc should return the name of the Tenant that
+# you want to switch to.
+# Rails.application.config.middleware.use 'Apartment::Elevators::Generic', lambda { |request|
+#   request.host.split('.').first
+# }
+
+# Rails.application.config.middleware.use 'Apartment::Elevators::Domain'
+#Rails.application.config.middleware.use 'Apartment::Elevators::Subdomain'
+# Rails.application.config.middleware.use 'Apartment::Elevators::FirstSubdomain'

data/config/initializers/aws.rb

@@ -0,0 +1,2 @@
+Aws.config.update({:logger => nil}) if defined?(Aws.config)
+AWS.config.update({:logger => nil}) if defined?(AWS.config)

data/config/initializers/elastic_apm.rb

@@ -0,0 +1,25 @@
+if defined?(ElasticAPM)
+  if ZuoraConnect.configuration.enable_apm && !defined?(Rails::Console)
+    ElasticAPM.agent.config.disable_send = false
+  else
+    ElasticAPM.agent.config.disable_send = true
+  end
+  case Rails.env.to_s
+  when 'production'
+    ElasticAPM.agent.config.server_url = "http://apm-server.logging:8200"
+    ElasticAPM.agent.config.transaction_sample_rate = 0.20
+    ElasticAPM.agent.config.capture_body = false
+  when 'staging'
+    ElasticAPM.agent.config.server_url = "http://apm-server.logging:8200"
+    ElasticAPM.agent.config.transaction_sample_rate = 1.0
+  when 'development'
+    ElasticAPM.agent.config.server_url = "http://logging.0.ecc.auw2.zuora:8200"
+    ElasticAPM.agent.config.transaction_sample_rate = 1.0
+  end
+  ElasticAPM.agent.config.pool_size = 1
+  ElasticAPM.agent.config.transaction_max_spans = 500
+  ElasticAPM.agent.config.ignore_url_patterns = ['^\/admin\/resque.*', '^\/admin\/redis.*', '^\/admin\/peek.*', '^\/peek.*']
+  ElasticAPM.agent.config.verify_server_cert = false
+  ElasticAPM.agent.config.log_level = Logger::INFO
+  ElasticAPM.agent.config.service_name = ::ZuoraConnect::Telegraf.app_name
+end

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,40 @@
+if defined? Prometheus
+  module Prometheus
+    require "zuora_connect/version"
+    require "zuora_api/version"
+
+    # 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: ZuoraConnect::Telegraf.app_name},0)
+    prometheus.register(CONNECT_VERSION);CONNECT_VERSION.set({version: ZuoraConnect::VERSION, name: ZuoraConnect::Telegraf.app_name},0)
+    prometheus.register(RAILS_VERSION);RAILS_VERSION.set({version: Rails.version, name: ZuoraConnect::Telegraf.app_name},0)
+    prometheus.register(RUBY_V);RUBY_V.set({version: RUBY_VERSION, name: ZuoraConnect::Telegraf.app_name},0)
+
+    # 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,13 @@
+redis_url = ENV["REDIS_URL"].present? ?  ENV["REDIS_URL"] : defined?(Rails.application.secrets.redis) ? Rails.application.secrets.redis : 'redis://localhost:6379/1'
+resque_url = ENV["RESQUE_URL"].present? ?  ENV["RESQUE_URL"] : defined?(Rails.application.secrets.resque) ? Rails.application.secrets.resque : 'redis://localhost:6379/1'
+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)
+  if defined?(Resque.redis)
+    Resque.redis = resque_url != redis_url ? Redis.new(:id => "#{ZuoraConnect::Telegraf.full_process_name(process_name: 'Resque')}", :url => resque_url, :timeout => 6, :reconnect_attempts => 2) : Redis.current
+  end
+end
+if defined?(RedisBrowser)
+  RedisBrowser.configure("connections" => { 
+  	"Redis" => { "url" => redis_url },
+  	"Resque" => { "url" => resque_url }})
+end

data/config/initializers/resque.rb

@@ -0,0 +1,22 @@
+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
+
+Resque.module_eval do
+  # Returns a hash, mapping queue names to queue sizes
+  def queue_sizes
+    paused_queues = Resque.redis.zrange("PauseQueue", 0, -1).map! {|key| key.split("__")[0]}
+    queue_names = queues.delete_if{|name| paused_queues.include?(name.split("_")[0])}
+
+    sizes = redis.pipelined do
+      queue_names.each do |name|
+        redis.llen("queue:#{name}")
+      end
+    end
+
+    Hash[queue_names.zip(sizes)]
+  end
+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,16 @@
+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
+  post '/initialize_app' => 'static#initialize_app'
+
+  namespace :api do
+    namespace :v1 do
+      resources :app_instance, :only => [:index], defaults: {format: :json} do
+          match "drop", via: [:get, :post], on: :collection
+          match "cache_bust", 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/db/migrate/20181206162339_add_fields_to_instance.rb

@@ -0,0 +1,5 @@
+class AddFieldsToInstance < ActiveRecord::Migration
+  def change
+  	add_column :zuora_connect_app_instances, :name, :string, default: "" unless column_exists? :zuora_connect_app_instances, :name
+  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