blazer 1.7.7 → 2.6.4

data/lib/blazer/adapters/soda_adapter.rb

@@ -0,0 +1,105 @@
+module Blazer
+  module Adapters
+    class SodaAdapter < BaseAdapter
+      def run_statement(statement, comment)
+        require "json"
+        require "net/http"
+        require "uri"
+
+        columns = []
+        rows = []
+        error = nil
+
+        # remove comments manually
+        statement = statement.gsub(/--.+/, "")
+        # only supports single line /* */ comments
+        # regex not perfect, but should be good enough
+        statement = statement.gsub(/\/\*.+\*\//, "")
+
+        # remove trailing semicolon
+        statement = statement.sub(/;\s*\z/, "")
+
+        # remove whitespace
+        statement = statement.squish
+
+        uri = URI(settings["url"])
+        uri.query = URI.encode_www_form("$query" => statement)
+
+        req = Net::HTTP::Get.new(uri)
+        req["X-App-Token"] = settings["app_token"] if settings["app_token"]
+
+        options = {
+          use_ssl: uri.scheme == "https",
+          open_timeout: 3,
+          read_timeout: 30
+        }
+
+        begin
+          # use Net::HTTP instead of soda-ruby for types and better error messages
+          res = Net::HTTP.start(uri.hostname, uri.port, options) do |http|
+            http.request(req)
+          end
+
+          if res.is_a?(Net::HTTPSuccess)
+            body = JSON.parse(res.body)
+
+            columns = JSON.parse(res["x-soda2-fields"])
+            column_types = columns.zip(JSON.parse(res["x-soda2-types"])).to_h
+
+            columns.reject! { |f| f.start_with?(":@") }
+            # rows can be missing some keys in JSON, so need to map by column
+            rows = body.map { |r| columns.map { |c| r[c] } }
+
+            columns.each_with_index do |column, i|
+              # nothing to do for boolean
+              case column_types[column]
+              when "number"
+                # check if likely an integer column
+                if rows.all? { |r| r[i].to_i == r[i].to_f }
+                  rows.each do |row|
+                    row[i] = row[i].to_i
+                  end
+                else
+                  rows.each do |row|
+                    row[i] = row[i].to_f
+                  end
+                end
+              when "floating_timestamp"
+                # check if likely a date column
+                if rows.all? { |r| r[i].end_with?("T00:00:00.000") }
+                  rows.each do |row|
+                    row[i] = Date.parse(row[i])
+                  end
+                else
+                  utc = ActiveSupport::TimeZone["Etc/UTC"]
+                  rows.each do |row|
+                    row[i] = utc.parse(row[i])
+                  end
+                end
+              end
+            end
+          else
+            error = JSON.parse(res.body)["message"] rescue "Bad response: #{res.code}"
+          end
+        rescue => e
+          error = e.message
+        end
+
+        [columns, rows, error]
+      end
+
+      def preview_statement
+        "SELECT * LIMIT 10"
+      end
+
+      def tables
+        ["all"]
+      end
+
+      # https://dev.socrata.com/docs/datatypes/text.html
+      def quoting
+        :single_quote_escape
+      end
+    end
+  end
+end

data/lib/blazer/adapters/spark_adapter.rb

@@ -0,0 +1,14 @@
+module Blazer
+  module Adapters
+    class SparkAdapter < HiveAdapter
+      def tables
+        client.execute("SHOW TABLES").map { |r| r["tableName"] }
+      end
+
+      # https://spark.apache.org/docs/latest/sql-ref-literals.html
+      def quoting
+        :backslash_escape
+      end
+    end
+  end
+end

data/lib/blazer/adapters/sql_adapter.rb

@@ -15,7 +15,7 @@ module Blazer
           end
       end
 
-      def run_statement(statement, comment)
+      def run_statement(statement, comment, bind_params = [])
         columns = []
         rows = []
         error = nil
@@ -24,16 +24,17 @@ module Blazer
           in_transaction do
             set_timeout(data_source.timeout) if data_source.timeout
 
-            result = select_all("#{statement} /*#{comment}*/")
+            binds = bind_params.map { |v| ActiveRecord::Relation::QueryAttribute.new(nil, v, ActiveRecord::Type::Value.new) }
+            result = connection_model.connection.select_all("#{statement} /*#{comment}*/", nil, binds)
             columns = result.columns
-            cast_method = Rails::VERSION::MAJOR < 5 ? :type_cast : :cast_value
             result.rows.each do |untyped_row|
-              rows << (result.column_types.empty? ? untyped_row : columns.each_with_index.map { |c, i| untyped_row[i] ? result.column_types[c].send(cast_method, untyped_row[i]) : untyped_row[i] })
+              rows << (result.column_types.empty? ? untyped_row : columns.each_with_index.map { |c, i| untyped_row[i] && result.column_types[c] ? result.column_types[c].send(:cast_value, untyped_row[i]) : untyped_row[i] })
             end
           end
         rescue => e
           error = e.message.sub(/.+ERROR: /, "")
           error = Blazer::TIMEOUT_MESSAGE if Blazer::TIMEOUT_ERRORS.any? { |e| error.include?(e) }
+          error = Blazer::VARIABLE_MESSAGE if error.include?("syntax error at or near \"$") || error.include?("Incorrect syntax near '@") || error.include?("your MySQL server version for the right syntax to use near '?")
           reconnect if error.include?("PG::ConnectionBad")
         end
 
@@ -41,18 +42,38 @@ module Blazer
       end
 
       def tables
-        result = data_source.run_statement(connection_model.send(:sanitize_sql_array, ["SELECT table_name FROM information_schema.tables WHERE table_schema IN (?) ORDER BY table_name", schemas]), refresh_cache: true)
-        result.rows.map(&:first)
+        sql = add_schemas("SELECT table_schema, table_name FROM information_schema.tables")
+        result = data_source.run_statement(sql, refresh_cache: true)
+        if postgresql? || redshift? || snowflake?
+          result.rows.sort_by { |r| [r[0] == default_schema ? "" : r[0], r[1]] }.map do |row|
+            table =
+              if row[0] == default_schema
+                row[1]
+              else
+                "#{row[0]}.#{row[1]}"
+              end
+
+            table = table.downcase if snowflake?
+
+            {
+              table: table,
+              value: connection_model.connection.quote_table_name(table)
+            }
+          end
+        else
+          result.rows.map(&:second).sort
+        end
       end
 
       def schema
-        result = data_source.run_statement(connection_model.send(:sanitize_sql_array, ["SELECT table_schema, table_name, column_name, data_type, ordinal_position FROM information_schema.columns WHERE table_schema IN (?) ORDER BY 1, 2", schemas]))
-        result.rows.group_by { |r| [r[0], r[1]] }.map { |k, vs| {schema: k[0], table: k[1], columns: vs.sort_by { |v| v[2] }.map { |v| {name: v[2], data_type: v[3]} }} }
+        sql = add_schemas("SELECT table_schema, table_name, column_name, data_type, ordinal_position FROM information_schema.columns")
+        result = data_source.run_statement(sql)
+        result.rows.group_by { |r| [r[0], r[1]] }.map { |k, vs| {schema: k[0], table: k[1], columns: vs.sort_by { |v| v[2] }.map { |v| {name: v[2], data_type: v[3]} }} }.sort_by { |t| [t[:schema] == default_schema ? "" : t[:schema], t[:table]] }
       end
 
       def preview_statement
-        if postgresql?
-          "SELECT * FROM \"{table}\" LIMIT 10"
+        if sqlserver?
+          "SELECT TOP (10) * FROM {table}"
         else
           "SELECT * FROM {table} LIMIT 10"
         end
@@ -64,13 +85,25 @@ module Blazer
 
       def cost(statement)
         result = explain(statement)
-        match = /cost=\d+\.\d+..(\d+\.\d+) /.match(result)
-        match[1] if match
+        if sqlserver?
+          result["TotalSubtreeCost"]
+        else
+          match = /cost=\d+\.\d+..(\d+\.\d+) /.match(result)
+          match[1] if match
+        end
       end
 
       def explain(statement)
         if postgresql? || redshift?
           select_all("EXPLAIN #{statement}").rows.first.first
+        elsif sqlserver?
+          begin
+            execute("SET SHOWPLAN_ALL ON")
+            result = select_all(statement).each.first
+          ensure
+            execute("SET SHOWPLAN_ALL OFF")
+          end
+          result
         end
       rescue
         nil
@@ -78,9 +111,9 @@ module Blazer
 
       def cancel(run_id)
         if postgresql?
-          select_all("SELECT pg_cancel_backend(pid) FROM pg_stat_activity WHERE pid <> pg_backend_pid() AND query LIKE '%,run_id:#{run_id}%'")
+          select_all("SELECT pg_cancel_backend(pid) FROM pg_stat_activity WHERE pid <> pg_backend_pid() AND query LIKE ?", ["%,run_id:#{run_id}%"])
         elsif redshift?
-          first_row = select_all("SELECT pid FROM stv_recents WHERE status = 'Running' AND query LIKE '%,run_id:#{run_id}%'").first
+          first_row = select_all("SELECT pid FROM stv_recents WHERE status = 'Running' AND query LIKE ?", ["%,run_id:#{run_id}%"]).first
           if first_row
             select_all("CANCEL #{first_row["pid"].to_i}")
           end
@@ -91,9 +124,95 @@ module Blazer
         !%w[CREATE ALTER UPDATE INSERT DELETE].include?(statement.split.first.to_s.upcase)
       end
 
+      def supports_cohort_analysis?
+        postgresql? || mysql?
+      end
+
+      # TODO treat date columns as already in time zone
+      def cohort_analysis_statement(statement, period:, days:)
+        raise "Cohort analysis not supported" unless supports_cohort_analysis?
+
+        cohort_column = statement =~ /\bcohort_time\b/ ? "cohort_time" : "conversion_time"
+        tzname = Blazer.time_zone.tzinfo.name
+
+        if mysql?
+          time_sql = "CONVERT_TZ(cohorts.cohort_time, '+00:00', ?)"
+          case period
+          when "day"
+            date_sql = "CAST(DATE_FORMAT(#{time_sql}, '%Y-%m-%d') AS DATE)"
+            date_params = [tzname]
+          when "week"
+            date_sql = "CAST(DATE_FORMAT(#{time_sql} - INTERVAL ((5 + DAYOFWEEK(#{time_sql})) % 7) DAY, '%Y-%m-%d') AS DATE)"
+            date_params = [tzname, tzname]
+          else
+            date_sql = "CAST(DATE_FORMAT(#{time_sql}, '%Y-%m-01') AS DATE)"
+            date_params = [tzname]
+          end
+          bucket_sql = "CAST(CEIL(TIMESTAMPDIFF(SECOND, cohorts.cohort_time, query.conversion_time) / ?) AS SIGNED)"
+        else
+          date_sql = "date_trunc(?, cohorts.cohort_time::timestamptz AT TIME ZONE ?)::date"
+          date_params = [period, tzname]
+          bucket_sql = "CEIL(EXTRACT(EPOCH FROM query.conversion_time - cohorts.cohort_time) / ?)::int"
+        end
+
+        # WITH not an optimization fence in Postgres 12+
+        statement = <<~SQL
+          WITH query AS (
+            {placeholder}
+          ),
+          cohorts AS (
+            SELECT user_id, MIN(#{cohort_column}) AS cohort_time FROM query
+            WHERE user_id IS NOT NULL AND #{cohort_column} IS NOT NULL
+            GROUP BY 1
+          )
+          SELECT
+            #{date_sql} AS period,
+            0 AS bucket,
+            COUNT(DISTINCT cohorts.user_id)
+          FROM cohorts GROUP BY 1
+          UNION ALL
+          SELECT
+            #{date_sql} AS period,
+            #{bucket_sql} AS bucket,
+            COUNT(DISTINCT query.user_id)
+          FROM cohorts INNER JOIN query ON query.user_id = cohorts.user_id
+          WHERE query.conversion_time IS NOT NULL
+          AND query.conversion_time >= cohorts.cohort_time
+          #{cohort_column == "conversion_time" ? "AND query.conversion_time != cohorts.cohort_time" : ""}
+          GROUP BY 1, 2
+        SQL
+        params = [statement] + date_params + date_params + [days.to_i * 86400]
+        connection_model.send(:sanitize_sql_array, params)
+      end
+
+      def quoting
+        ->(value) { connection_model.connection.quote(value) }
+      end
+
+      # Redshift adapter silently ignores binds
+      def parameter_binding
+        if postgresql? && (ActiveRecord::VERSION::STRING.to_f >= 6.1 || prepared_statements?)
+          # Active Record < 6.1 silently ignores binds with Postgres when prepared statements are disabled
+          :numeric
+        elsif sqlite?
+          :numeric
+        elsif mysql? && prepared_statements?
+          # Active Record silently ignores binds with MySQL when prepared statements are disabled
+          :positional
+        elsif sqlserver?
+          proc do |statement, variables|
+            variables.each_with_index do |(k, _), i|
+              statement = statement.gsub("{#{k}}", "@#{i} ")
+            end
+            [statement, variables.values]
+          end
+        end
+      end
+
       protected
 
-      def select_all(statement)
+      def select_all(statement, params = [])
+        statement = connection_model.send(:sanitize_sql_array, [statement] + params) if params.any?
         connection_model.connection.select_all(statement)
       end
 
@@ -114,20 +233,64 @@ module Blazer
         ["MySQL", "Mysql2", "Mysql2Spatial"].include?(adapter_name)
       end
 
+      def sqlite?
+        ["SQLite"].include?(adapter_name)
+      end
+
+      def sqlserver?
+        ["SQLServer", "tinytds", "mssql"].include?(adapter_name)
+      end
+
+      def snowflake?
+        data_source.adapter == "snowflake"
+      end
+
       def adapter_name
-        connection_model.connection.adapter_name
+        # prevent bad data source from taking down queries/new
+        connection_model.connection.adapter_name rescue nil
+      end
+
+      def default_schema
+        @default_schema ||= begin
+          if postgresql? || redshift?
+            "public"
+          elsif sqlserver?
+            "dbo"
+          elsif connection_model.respond_to?(:connection_db_config)
+            connection_model.connection_db_config.database
+          else
+            connection_model.connection_config[:database]
+          end
+        end
       end
 
-      def schemas
-        default_schema = (postgresql? || redshift?) ? "public" : connection_model.connection_config[:database]
-        settings["schemas"] || [connection_model.connection_config[:schema] || default_schema]
+      def add_schemas(query)
+        if settings["schemas"]
+          where = "table_schema IN (?)"
+          schemas = settings["schemas"]
+        elsif mysql?
+          where = "table_schema IN (?)"
+          schemas = [default_schema]
+        else
+          where = "table_schema NOT IN (?)"
+          schemas = ["information_schema"]
+          schemas.map!(&:upcase) if snowflake?
+          schemas << "pg_catalog" if postgresql? || redshift?
+        end
+        connection_model.send(:sanitize_sql_array, ["#{query} WHERE #{where}", schemas])
       end
 
       def set_timeout(timeout)
         if postgresql? || redshift?
           execute("SET #{use_transaction? ? "LOCAL " : ""}statement_timeout = #{timeout.to_i * 1000}")
         elsif mysql?
-          execute("SET max_execution_time = #{timeout.to_i * 1000}")
+          # use send as this method is private in Rails 4.2
+          mariadb = connection_model.connection.send(:mariadb?) rescue false
+          if mariadb
+            execute("SET max_statement_time = #{timeout.to_i * 1000}")
+          else
+            execute("SET max_execution_time = #{timeout.to_i * 1000}")
+          end
         else
           raise Blazer::TimeoutNotSupported, "Timeout not supported for #{adapter_name} adapter"
         end
@@ -149,6 +312,10 @@ module Blazer
           end
         end
       end
+
+      def prepared_statements?
+        connection_model.connection.prepared_statements
+      end
     end
   end
 end

data/lib/blazer/data_source.rb

@@ -4,31 +4,13 @@ module Blazer
   class DataSource
     extend Forwardable
 
-    attr_reader :id, :settings, :adapter, :adapter_instance
+    attr_reader :id, :settings
 
-    def_delegators :adapter_instance, :schema, :tables, :preview_statement, :reconnect, :cost, :explain, :cancel
+    def_delegators :adapter_instance, :schema, :tables, :preview_statement, :reconnect, :cost, :explain, :cancel, :supports_cohort_analysis?, :cohort_analysis_statement
 
     def initialize(id, settings)
       @id = id
       @settings = settings
-
-      unless settings["url"] || Rails.env.development?
-        raise Blazer::Error, "Empty url for data source: #{id}"
-      end
-
-      @adapter_instance =
-        case adapter
-        when "elasticsearch"
-          Blazer::Adapters::ElasticsearchAdapter.new(self)
-        when "mongodb"
-          Blazer::Adapters::MongodbAdapter.new(self)
-        when "presto"
-          Blazer::Adapters::PrestoAdapter.new(self)
-        when "sql"
-          Blazer::Adapters::SqlAdapter.new(self)
-        else
-          raise Blazer::Error, "Unknown adapter"
-        end
     end
 
     def adapter
@@ -107,8 +89,19 @@ module Blazer
       Blazer.cache.delete(run_cache_key(run_id))
     end
 
+    def sub_variables(statement, vars)
+      statement = statement.dup
+      vars.each do |var, value|
+        # use block form to disable back-references
+        statement.gsub!("{#{var}}") { quote(value) }
+      end
+      statement
+    end
+
     def run_statement(statement, options = {})
-      run_id = options[:run_id]
+      statement = Statement.new(statement, self) if statement.is_a?(String)
+      statement.bind unless statement.bind_statement
+
       async = options[:async]
       result = nil
       if cache_mode != "off"
@@ -137,7 +130,7 @@ module Blazer
         if options[:run_id]
           comment << ",run_id:#{options[:run_id]}"
         end
-        result = run_statement_helper(statement, comment, async ? options[:run_id] : nil)
+        result = run_statement_helper(statement, comment, async ? options[:run_id] : nil, options)
       end
 
       result
@@ -152,18 +145,101 @@ module Blazer
     end
 
     def statement_cache_key(statement)
-      cache_key(["statement", id, Digest::MD5.hexdigest(statement.to_s.gsub("\r\n", "\n"))])
+      cache_key(["statement", id, Digest::MD5.hexdigest(statement.bind_statement.to_s.gsub("\r\n", "\n") + statement.bind_values.to_json)])
     end
 
     def run_cache_key(run_id)
       cache_key(["run", run_id])
     end
 
+    def quote(value)
+      if quoting == :backslash_escape || quoting == :single_quote_escape
+        # only need to support types generated by process_vars
+        if value.is_a?(Integer) || value.is_a?(Float)
+          value.to_s
+        elsif value.nil?
+          "NULL"
+        else
+          value = value.to_formatted_s(:db) if value.is_a?(ActiveSupport::TimeWithZone)
+
+          if quoting == :backslash_escape
+            "'#{value.gsub("\\") { "\\\\" }.gsub("'") { "\\'" }}'"
+          else
+            "'#{value.gsub("'", "''")}'"
+          end
+        end
+      elsif quoting.respond_to?(:call)
+        quoting.call(value)
+      elsif quoting.nil?
+        raise Blazer::Error, "Quoting not specified"
+      else
+        raise Blazer::Error, "Unknown quoting"
+      end
+    end
+
+    def bind_params(statement, variables)
+      if parameter_binding == :positional
+        locations = []
+        variables.each do |k, v|
+          i = 0
+          while (idx = statement.index("{#{k}}", i))
+            locations << [v, idx]
+            i = idx + 1
+          end
+        end
+        variables.each do |k, v|
+          statement = statement.gsub("{#{k}}", "?")
+        end
+        [statement, locations.sort_by(&:last).map(&:first)]
+      elsif parameter_binding == :numeric
+        variables.each_with_index do |(k, v), i|
+          # add trailing space if followed by digit
+          # try to keep minimal to avoid fixing invalid queries like SELECT{var}
+          statement = statement.gsub(/#{Regexp.escape("{#{k}}")}(\d)/, "$#{i + 1} \\1").gsub("{#{k}}", "$#{i + 1}")
+        end
+        [statement, variables.values]
+      elsif parameter_binding.respond_to?(:call)
+        parameter_binding.call(statement, variables)
+      elsif parameter_binding.nil?
+        [sub_variables(statement, variables), []]
+      else
+        raise Blazer::Error, "Unknown bind parameters"
+      end
+    end
+
     protected
 
-    def run_statement_helper(statement, comment, run_id)
+    def adapter_instance
+      @adapter_instance ||= begin
+        # TODO add required settings to adapters
+        unless settings["url"] || Rails.env.development? || ["bigquery", "athena", "snowflake", "salesforce"].include?(settings["adapter"])
+          raise Blazer::Error, "Empty url for data source: #{id}"
+        end
+
+        unless Blazer.adapters[adapter]
+          raise Blazer::Error, "Unknown adapter"
+        end
+
+        Blazer.adapters[adapter].new(self)
+      end
+    end
+
+    def quoting
+      @quoting ||= adapter_instance.quoting
+    end
+
+    def parameter_binding
+      @parameter_binding ||= adapter_instance.parameter_binding
+    end
+
+    def run_statement_helper(statement, comment, run_id, options)
       start_time = Time.now
-      columns, rows, error = @adapter_instance.run_statement(statement, comment)
+      columns, rows, error =
+        if adapter_instance.parameter_binding
+          adapter_instance.run_statement(statement.bind_statement, comment, statement.bind_values)
+        else
+          adapter_instance.run_statement(statement.bind_statement, comment)
+        end
       duration = Time.now - start_time
 
       cache_data = nil
@@ -172,7 +248,7 @@ module Blazer
         cache_data = Marshal.dump([columns, rows, error, cache ? Time.now : nil]) rescue nil
       end
 
-      if cache && cache_data && @adapter_instance.cachable?(statement)
+      if cache && cache_data && adapter_instance.cachable?(statement.bind_statement)
         Blazer.cache.write(statement_cache_key(statement), cache_data, expires_in: cache_expires_in.to_f * 60)
       end
 
@@ -187,11 +263,12 @@ module Blazer
       Blazer::Result.new(self, columns, rows, error, nil, cache && !cache_data.nil?)
     end
 
+    # TODO check for adapter with same name, default to sql
     def detect_adapter
-      schema = settings["url"].to_s.split("://").first
-      case schema
-      when "mongodb", "presto"
-        schema
+      scheme = settings["url"].to_s.split("://").first
+      case scheme
+      when "mongodb", "presto", "cassandra", "ignite"
+        scheme
       else
         "sql"
       end

data/lib/blazer/engine.rb

@@ -3,40 +3,38 @@ module Blazer
     isolate_namespace Blazer
 
     initializer "blazer" do |app|
-      # use a proc instead of a string
-      app.config.assets.precompile << proc { |path| path =~ /\Ablazer\/application\.(js|css)\z/ }
-      app.config.assets.precompile << proc { |path| path =~ /\Ablazer\/.+\.(eot|svg|ttf|woff)\z/ }
+      if defined?(Sprockets) && Sprockets::VERSION >= "4"
+        app.config.assets.precompile << "blazer/application.js"
+        app.config.assets.precompile << "blazer/application.css"
+        app.config.assets.precompile << "blazer/glyphicons-halflings-regular.eot"
+        app.config.assets.precompile << "blazer/glyphicons-halflings-regular.svg"
+        app.config.assets.precompile << "blazer/glyphicons-halflings-regular.ttf"
+        app.config.assets.precompile << "blazer/glyphicons-halflings-regular.woff"
+        app.config.assets.precompile << "blazer/glyphicons-halflings-regular.woff2"
+        app.config.assets.precompile << "blazer/favicon.png"
+      else
+        # use a proc instead of a string
+        app.config.assets.precompile << proc { |path| path =~ /\Ablazer\/application\.(js|css)\z/ }
+        app.config.assets.precompile << proc { |path| path =~ /\Ablazer\/.+\.(eot|svg|ttf|woff|woff2)\z/ }
+        app.config.assets.precompile << proc { |path| path == "blazer/favicon.png" }
+      end
 
       Blazer.time_zone ||= Blazer.settings["time_zone"] || Time.zone
       Blazer.audit = Blazer.settings.key?("audit") ? Blazer.settings["audit"] : true
       Blazer.user_name = Blazer.settings["user_name"] if Blazer.settings["user_name"]
       Blazer.from_email = Blazer.settings["from_email"] if Blazer.settings["from_email"]
-      Blazer.before_action = Blazer.settings["before_action"] if Blazer.settings["before_action"]
-
-      Blazer.user_class ||= Blazer.settings.key?("user_class") ? Blazer.settings["user_class"] : (User rescue nil)
-      Blazer.user_method = Blazer.settings["user_method"]
-      if Blazer.user_class
-        Blazer.user_method ||= "current_#{Blazer.user_class.to_s.downcase.singularize}"
-      end
-
+      Blazer.before_action = Blazer.settings["before_action_method"] if Blazer.settings["before_action_method"]
       Blazer.check_schedules = Blazer.settings["check_schedules"] if Blazer.settings.key?("check_schedules")
-
-      if Blazer.user_class
-        options = Blazer::BELONGS_TO_OPTIONAL.merge(class_name: Blazer.user_class.to_s)
-        Blazer::Query.belongs_to :creator, options
-        Blazer::Dashboard.belongs_to :creator, options
-        Blazer::Check.belongs_to :creator, options
-      end
-
       Blazer.cache ||= Rails.cache
 
       Blazer.anomaly_checks = Blazer.settings["anomaly_checks"] || false
+      Blazer.forecasting = Blazer.settings["forecasting"] || false
       Blazer.async = Blazer.settings["async"] || false
-      if Blazer.async
-        require "blazer/run_statement_job"
-      end
-
       Blazer.images = Blazer.settings["images"] || false
+      Blazer.override_csp = Blazer.settings["override_csp"] || false
+      Blazer.slack_oauth_token = Blazer.settings["slack_oauth_token"] || ENV["BLAZER_SLACK_OAUTH_TOKEN"]
+      Blazer.slack_webhook_url = Blazer.settings["slack_webhook_url"] || ENV["BLAZER_SLACK_WEBHOOK_URL"]
+      Blazer.mapbox_access_token = Blazer.settings["mapbox_access_token"] || ENV["MAPBOX_ACCESS_TOKEN"]
     end
   end
 end