zuora_connectD 1.7.09

data/app/models/zuora_connect/login.rb

@@ -0,0 +1,36 @@
+module ZuoraConnect
+  class Login
+
+    def initialize (fields)
+      @clients = {}
+      if fields["tenant_type"] == "Zuora"
+        login_fields = fields.map{|k,v| [k.to_sym, v]}.to_h
+        login_type = fields.dig("authentication_type").blank? ? 'Basic' : fields.dig("authentication_type").capitalize
+        
+        @clients["Default"] = "::ZuoraAPI::#{login_type}".constantize.new(login_fields)
+        @default_entity = fields["entities"][0]["id"] if fields["entities"].size == 1 if fields["entities"] && fields["entities"].size > 0
+        if fields["entities"] && fields["entities"].size > 0
+          fields["entities"].each do |entity|
+            params = {:entity_id => entity["id"]}.merge(login_fields)
+            @clients[entity["id"]] =  "::ZuoraAPI::#{login_type}".constantize.new(params)
+          end
+        end
+        self.attr_builder("available_entities", @clients.keys) 
+      end
+      fields.each do |k,v|
+        self.attr_builder(k,v)
+      end
+      @default_entity ||= "Default"
+    end
+
+    def attr_builder(field,val)
+      singleton_class.class_eval { attr_accessor "#{field}" }
+      send("#{field}=", val)
+    end
+
+    def client(id = @default_entity)
+      return id.blank? ? @clients[@default_entity] : @clients[id]
+    end
+
+  end
+end

data/app/models/zuora_connect/telegraf.rb

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

data/app/views/layouts/zuora_connect/application.html.erb

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Connect</title>
+  <%= stylesheet_link_tag    "zuora_connectD/application", media: "all" %>
+  <%= javascript_include_tag "zuora_connectD/application" %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/app/views/sql/refresh_aggregate_table.txt

@@ -0,0 +1,84 @@
+CREATE OR REPLACE FUNCTION "shared_extensions".refresh_aggregate_table(aggregate_table_name text, table_name text, filter text, mode text) RETURNS void AS $$
+DECLARE
+  schema RECORD;
+  result RECORD;
+  sql TEXT := '';
+  i INTEGER;
+  created boolean := false;
+  fields_order character varying;
+  index_name varchar;
+  index_string varchar;
+  index_id varchar;
+BEGIN
+  IF mode = 'Table' THEN
+    raise notice 'Starting aggregate of % to %', table_name, aggregate_table_name;
+
+
+    EXECUTE format('DROP TABLE IF EXISTS "public".%I', aggregate_table_name);
+    raise notice 'Filter %', filter;
+
+    FOR schema IN EXECUTE
+      format(
+        'SELECT schema_name FROM information_schema.schemata WHERE schema_name ~ ''^[0-9]+$'''
+      )
+    LOOP
+      IF NOT created THEN
+        -- Create the aggregate table if we haven't already
+        EXECUTE format(
+          'CREATE TABLE "public".%I (LIKE %I.%I)',
+          aggregate_table_name,
+          schema.schema_name, table_name
+        );
+        -- Add a special `schema_name` column, which we'll populate with the name of the schema
+        -- each row originated from
+        EXECUTE format(
+          'ALTER TABLE "public".%I ADD COLUMN schema_name text', aggregate_table_name
+        );
+        created := true;
+      END IF;
+
+      -- Finally, we'll select everything from this schema's target table, plus the schema's name,
+      -- and insert them into our new aggregate table
+      EXECUTE format(
+        'SELECT string_agg(column_name, '','') from information_schema.columns where table_name = ''%s'' AND table_schema = ''%s''',  
+        table_name, schema.schema_name
+      ) into fields_order;
+      
+      raise notice 'Importing Schema %', schema.schema_name;
+
+      EXECUTE format(        
+        'INSERT INTO "public".%I (schema_name, %s) (SELECT ''%s'' AS schema_name, * FROM %I.%I  %s )',
+        aggregate_table_name,
+        fields_order,
+        schema.schema_name,
+        schema.schema_name, table_name, 
+        filter
+      );
+    END LOOP;
+
+    EXECUTE
+      format('CREATE INDEX ON "public".%I (schema_name)', aggregate_table_name);
+    EXECUTE
+      format('CREATE INDEX ON "public".%I (id)', aggregate_table_name);
+  END IF;
+  IF mode = 'Index' THEN
+    FOR index_string, index_name, index_id IN
+       SELECT pg_get_indexdef(idx.oid)||';', idx.relname, idx.oid
+       from pg_index ind
+       join pg_class idx on idx.oid = ind.indexrelid
+       join pg_class tbl on tbl.oid = ind.indrelid
+       left join pg_namespace ns on ns.oid = tbl.relnamespace where idx.relname != concat(table_name, '_pkey') and tbl.relname = table_name and ns.nspname = 'public'
+    LOOP
+      BEGIN
+        EXECUTE
+          format('DROP INDEX IF EXISTS "public"."%s"', concat(aggregate_table_name, '_', index_id));
+
+        EXECUTE
+          format(replace(replace(index_string, index_name, concat(aggregate_table_name, '_', index_id)), concat(' ', table_name, ' '), concat( ' ', aggregate_table_name, ' ')));
+
+        RAISE NOTICE 'Creating Indexes %', replace(replace(replace(index_string, index_name, concat(aggregate_table_name, '_', index_id)), concat(' ', table_name, ' '), concat( ' ', aggregate_table_name, ' ')), concat('public.', table_name), concat( 'public.', aggregate_table_name)) ;
+      END;
+    END LOOP;
+  END IF;
+END
+$$ LANGUAGE plpgsql;

data/app/views/zuora_connect/static/invalid_app_instance_error.html.erb

@@ -0,0 +1,65 @@
+<html><head>
+  <title>We're sorry, but something went wrong (500)</title>
+  <meta name="viewport" content="width=device-width,initial-scale=1">
+  <style>
+  body {
+    background-color: #EFEFEF;
+    color: #2E2F30;
+    text-align: center;
+    font-family: arial, sans-serif;
+    margin: 0;
+  }
+
+  div.dialog {
+    width: 95%;
+    max-width: 33em;
+    margin: 4em auto 0;
+  }
+
+  div.dialog > div {
+    border: 1px solid #CCC;
+    border-right-color: #999;
+    border-left-color: #999;
+    border-bottom-color: #BBB;
+    border-top: #B00100 solid 4px;
+    border-top-left-radius: 9px;
+    border-top-right-radius: 9px;
+    background-color: white;
+    padding: 7px 12% 0;
+    box-shadow: 0 3px 8px rgba(50, 50, 50, 0.17);
+  }
+
+  h1 {
+    font-size: 100%;
+    color: #730E15;
+    line-height: 1.5em;
+  }
+
+  div.dialog > p {
+    margin: 0 0 1em;
+    padding: 1em;
+    background-color: #F7F7F7;
+    border: 1px solid #CCC;
+    border-right-color: #999;
+    border-left-color: #999;
+    border-bottom-color: #999;
+    border-bottom-left-radius: 4px;
+    border-bottom-right-radius: 4px;
+    border-top-color: #DADADA;
+    color: #666;
+    box-shadow: 0 3px 8px rgba(50, 50, 50, 0.17);
+  }
+  </style>
+</head>
+
+<body>
+  <!-- This file lives in public/500.html -->
+  <div class="dialog">
+    <div>
+      <h1>We're sorry, but this request could not be verified.</h1>
+    </div>
+    <p>Please try relaunching this application at connect.zuora.com</p>
+  </div>
+
+
+</body></html>

data/app/views/zuora_connect/static/session_error.html.erb

@@ -0,0 +1,63 @@
+<html><head>
+  <title>We're sorry, but something went wrong (500)</title>
+  <meta name="viewport" content="width=device-width,initial-scale=1">
+  <style>
+  body {
+    background-color: #EFEFEF;
+    color: #2E2F30;
+    text-align: center;
+    font-family: arial, sans-serif;
+    margin: 0;
+  }
+
+  div.dialog {
+    width: 95%;
+    max-width: 33em;
+    margin: 4em auto 0;
+  }
+
+  div.dialog > div {
+    border: 1px solid #CCC;
+    border-right-color: #999;
+    border-left-color: #999;
+    border-bottom-color: #BBB;
+    border-top: #B00100 solid 4px;
+    border-top-left-radius: 9px;
+    border-top-right-radius: 9px;
+    background-color: white;
+    padding: 7px 12% 0;
+    box-shadow: 0 3px 8px rgba(50, 50, 50, 0.17);
+  }
+
+  h1 {
+    font-size: 100%;
+    color: #730E15;
+    line-height: 1.5em;
+  }
+
+  div.dialog > p {
+    margin: 0 0 1em;
+    padding: 1em;
+    background-color: #F7F7F7;
+    border: 1px solid #CCC;
+    border-right-color: #999;
+    border-left-color: #999;
+    border-bottom-color: #999;
+    border-bottom-left-radius: 4px;
+    border-bottom-right-radius: 4px;
+    border-top-color: #DADADA;
+    color: #666;
+    box-shadow: 0 3px 8px rgba(50, 50, 50, 0.17);
+  }
+  </style>
+</head>
+
+<body>
+  <!-- This file lives in public/500.html -->
+  <div class="dialog">
+    <div>
+      <h1>Session is invalid</h1>
+    </div>
+    <p>Please try relaunching the application from connect.zuora.com</p>
+  </div>
+</body></html>

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'