blazer 1.8.0 → 1.8.2

data/app/assets/javascripts/blazer/queries.js

@@ -52,6 +52,9 @@ function runQueryHelper(query) {
   }).fail( function(jqXHR, textStatus, errorThrown) {
     if (!query.canceled) {
       var message = (typeof errorThrown === "string") ? errorThrown : errorThrown.message
+      if (!message) {
+        message = "An error occurred"
+      }
       query.error(message)
     }
     queryComplete(query)
@@ -92,7 +95,7 @@ function cancelQuery(query) {
   var path = Routes.cancel_queries_path()
   var data = {run_id: query.run_id, data_source: query.data_source}
   if (navigator.sendBeacon) {
-    navigator.sendBeacon(path, csrfProtect(data))
+    navigator.sendBeacon(path + "?" + $.param(csrfProtect(data)))
   } else {
     // TODO make sync
     $.post(path, data)
@@ -103,5 +106,5 @@ function csrfProtect(payload) {
   var param = $("meta[name=csrf-param]").attr("content")
   var token = $("meta[name=csrf-token]").attr("content")
   if (param && token) payload[param] = token
-  return new Blob([JSON.stringify(payload)], {type : "application/json; charset=utf-8"})
+  return payload
 }

data/app/controllers/blazer/queries_controller.rb

@@ -183,7 +183,7 @@ module Blazer
 
     def cancel
       Blazer.data_sources[params[:data_source]].cancel(blazer_run_id)
-      render json: {}
+      head :ok
     end
 
     private

data/app/models/blazer/audit.rb

@@ -1,5 +1,5 @@
 module Blazer
-  class Audit < ActiveRecord::Base
+  class Audit < Record
     belongs_to :user, Blazer::BELONGS_TO_OPTIONAL.merge(class_name: Blazer.user_class.to_s)
     belongs_to :query, Blazer::BELONGS_TO_OPTIONAL
   end

data/app/models/blazer/check.rb

@@ -1,5 +1,5 @@
 module Blazer
-  class Check < ActiveRecord::Base
+  class Check < Record
     belongs_to :creator, Blazer::BELONGS_TO_OPTIONAL.merge(class_name: Blazer.user_class.to_s) if Blazer.user_class
     belongs_to :query
 

data/app/models/blazer/dashboard.rb

@@ -1,5 +1,5 @@
 module Blazer
-  class Dashboard < ActiveRecord::Base
+  class Dashboard < Record
     belongs_to :creator, Blazer::BELONGS_TO_OPTIONAL.merge(class_name: Blazer.user_class.to_s) if Blazer.user_class
     has_many :dashboard_queries, dependent: :destroy
     has_many :queries, through: :dashboard_queries

data/app/models/blazer/dashboard_query.rb

@@ -1,5 +1,5 @@
 module Blazer
-  class DashboardQuery < ActiveRecord::Base
+  class DashboardQuery < Record
     belongs_to :dashboard
     belongs_to :query
 

data/app/models/blazer/query.rb

@@ -1,5 +1,5 @@
 module Blazer
-  class Query < ActiveRecord::Base
+  class Query < Record
     belongs_to :creator, Blazer::BELONGS_TO_OPTIONAL.merge(class_name: Blazer.user_class.to_s) if Blazer.user_class
     has_many :checks, dependent: :destroy
     has_many :dashboard_queries, dependent: :destroy
@@ -19,7 +19,7 @@ module Blazer
     end
 
     def editable?(user)
-      editable = !persisted? || (name.present? && name.first != "*" && name.first != "#") || user == creator
+      editable = !persisted? || (name.present? && name.first != "*" && name.first != "#") || user == try(:creator)
       editable &&= Blazer.query_editable.call(self, user) if Blazer.query_editable
       editable
     end

data/app/models/blazer/record.rb

@@ -0,0 +1,5 @@
+module Blazer
+  class Record < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/views/blazer/queries/_form.html.erb

@@ -66,7 +66,7 @@
 
 <script>
   <%= blazer_js_var "params", variable_params %>
-  <%= blazer_js_var "previewStatement", Hash[Blazer.data_sources.map { |k, v| [k, v.preview_statement] }] %>
+  <%= blazer_js_var "previewStatement", Hash[Blazer.data_sources.map { |k, v| [k, (v.preview_statement rescue "")] }] %>
 
   var app = new Vue({
     el: "#app",

data/app/views/blazer/queries/run.html.erb

@@ -111,6 +111,8 @@
       <div class="results-container">
         <% if @columns == ["QUERY PLAN"] %>
           <pre><code><%= @rows.map { |r| r[0] }.join("\n") %></code></pre>
+        <% elsif @columns == ["PLAN"] && @data_source.adapter == "druid" %>
+          <pre><code><%= @rows[0][0] %></code></pre>
         <% else %>
           <table class="table results-table" style="margin-bottom: 0;">
             <thead>

data/app/views/blazer/queries/show.html.erb

@@ -62,7 +62,7 @@
   </script>
 <% end %>
 
-<% if %w[sql presto drill bigquery].include?(Blazer.data_sources[@query.data_source].adapter) %>
+<% unless %w(mongodb elasticsearch).include?(Blazer.data_sources[@query.data_source].adapter) %>
   <script>
     // do not highlight really long queries
     // this can lead to performance issues

data/blazer.gemspec

@@ -17,7 +17,8 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "rails"
+  spec.add_dependency "railties", ">= 4"
+  spec.add_dependency "activerecord", ">= 4"
   spec.add_dependency "chartkick"
   spec.add_dependency "safely_block", ">= 0.1.1"
 

data/lib/blazer.rb

@@ -7,8 +7,11 @@ require "blazer/data_source"
 require "blazer/result"
 require "blazer/run_statement"
 require "blazer/adapters/base_adapter"
+require "blazer/adapters/athena_adapter"
 require "blazer/adapters/bigquery_adapter"
+require "blazer/adapters/cassandra_adapter"
 require "blazer/adapters/drill_adapter"
+require "blazer/adapters/druid_adapter"
 require "blazer/adapters/elasticsearch_adapter"
 require "blazer/adapters/mongodb_adapter"
 require "blazer/adapters/presto_adapter"
@@ -23,8 +26,8 @@ module Blazer
     attr_accessor :audit
     attr_reader :time_zone
     attr_accessor :user_name
-    attr_accessor :user_class
-    attr_accessor :user_method
+    attr_writer :user_class
+    attr_writer :user_method
     attr_accessor :before_action
     attr_accessor :from_email
     attr_accessor :cache
@@ -58,6 +61,23 @@ module Blazer
     @time_zone = time_zone.is_a?(ActiveSupport::TimeZone) ? time_zone : ActiveSupport::TimeZone[time_zone.to_s]
   end
 
+  def self.user_class
+    if !defined?(@user_class)
+      @user_class = settings.key?("user_class") ? settings["user_class"] : (User.name rescue nil)
+    end
+    @user_class
+  end
+
+  def self.user_method
+    if !defined?(@user_method)
+      @user_method = settings["user_method"]
+      if user_class
+        @user_method ||= "current_#{user_class.to_s.downcase.singularize}"
+      end
+    end
+    @user_method
+  end
+
   def self.settings
     @settings ||= begin
       path = Rails.root.join("config", "blazer.yml").to_s
@@ -129,7 +149,14 @@ module Blazer
           break
         end
       end
-      check.update_state(result)
+
+      begin
+        check.reload # in case state has changed since job started
+        check.update_state(result)
+      rescue ActiveRecord::RecordNotFound
+        # check deleted
+      end
+
       # TODO use proper logfmt
       Rails.logger.info "[blazer check] query=#{check.query.name} state=#{check.state} rows=#{result.rows.try(:size)} error=#{result.error}"
 
@@ -166,9 +193,12 @@ module Blazer
   end
 end
 
-Blazer.register_adapter "drill", Blazer::Adapters::DrillAdapter
+Blazer.register_adapter "athena", Blazer::Adapters::AthenaAdapter
 Blazer.register_adapter "bigquery", Blazer::Adapters::BigQueryAdapter
+Blazer.register_adapter "cassandra", Blazer::Adapters::CassandraAdapter
+Blazer.register_adapter "drill", Blazer::Adapters::DrillAdapter
+Blazer.register_adapter "druid", Blazer::Adapters::DruidAdapter
 Blazer.register_adapter "elasticsearch", Blazer::Adapters::ElasticsearchAdapter
-Blazer.register_adapter "mongodb", Blazer::Adapters::MongodbAdapter
 Blazer.register_adapter "presto", Blazer::Adapters::PrestoAdapter
+Blazer.register_adapter "mongodb", Blazer::Adapters::MongodbAdapter
 Blazer.register_adapter "sql", Blazer::Adapters::SqlAdapter

data/lib/blazer/adapters/athena_adapter.rb

@@ -0,0 +1,128 @@
+module Blazer
+  module Adapters
+    class AthenaAdapter < BaseAdapter
+      def run_statement(statement, comment)
+        require "digest/md5"
+
+        columns = []
+        rows = []
+        error = nil
+
+        begin
+          resp =
+            client.start_query_execution(
+              query_string: statement,
+              # use token so we fetch cached results after query is run
+              client_request_token: Digest::MD5.hexdigest(statement),
+              query_execution_context: {
+                database: database,
+              },
+              result_configuration: {
+                output_location: settings["output_location"]
+              }
+            )
+          query_execution_id = resp.query_execution_id
+
+          timeout = data_source.timeout || 300
+          stop_at = Time.now + timeout
+          resp = nil
+
+          begin
+            resp = client.get_query_results(
+              query_execution_id: query_execution_id
+            )
+          rescue Aws::Athena::Errors::InvalidRequestException => e
+            if e.message != "Query has not yet finished. Current state: RUNNING"
+              raise e
+            end
+            if Time.now < stop_at
+              sleep(3)
+              retry
+            end
+          end
+
+          if resp && resp.result_set
+            column_info = resp.result_set.result_set_metadata.column_info
+            columns = column_info.map(&:name)
+            column_types = column_info.map(&:type)
+
+            untyped_rows = []
+
+            # paginated
+            resp.each do |page|
+              untyped_rows.concat page.result_set.rows.map { |r| r.data.map(&:var_char_value) }
+            end
+
+            utc = ActiveSupport::TimeZone['Etc/UTC']
+
+            rows = untyped_rows[1..-1] || []
+            column_types.each_with_index do |ct, i|
+              # TODO more column_types
+              case ct
+              when "timestamp"
+                rows.each do |row|
+                  row[i] = utc.parse(row[i])
+                end
+              when "date"
+                rows.each do |row|
+                  row[i] = Date.parse(row[i])
+                end
+              when "bigint"
+                rows.each do |row|
+                  row[i] = row[i].to_i
+                end
+              when "double"
+                rows.each do |row|
+                  row[i] = row[i].to_f
+                end
+              end
+            end
+          elsif resp
+            error = fetch_error(query_execution_id)
+          else
+            error = Blazer::TIMEOUT_MESSAGE
+          end
+        rescue Aws::Athena::Errors::InvalidRequestException => e
+          error = e.message
+          if error == "Query did not finish successfully. Final query state: FAILED"
+            error = fetch_error(query_execution_id)
+          end
+        end
+
+        [columns, rows, error]
+      end
+
+      def tables
+        glue.get_tables(database_name: database).table_list.map(&:name).sort
+      end
+
+      def schema
+        glue.get_tables(database_name: database).table_list.map { |t| {table: t.name, columns: t.storage_descriptor.columns.map { |c| {name: c.name, data_type: c.type} }} }
+      end
+
+      def preview_statement
+        "SELECT * FROM {table} LIMIT 10"
+      end
+
+      private
+
+      def database
+        @database ||= settings["database"] || "default"
+      end
+
+      def fetch_error(query_execution_id)
+        client.get_query_execution(
+          query_execution_id: query_execution_id
+        ).query_execution.status.state_change_reason
+      end
+
+      def client
+        @client ||= Aws::Athena::Client.new
+      end
+
+      def glue
+        @glue ||= Aws::Glue::Client.new
+      end
+    end
+  end
+end

data/lib/blazer/adapters/cassandra_adapter.rb

@@ -0,0 +1,59 @@
+module Blazer
+  module Adapters
+    class CassandraAdapter < BaseAdapter
+      def run_statement(statement, comment)
+        columns = []
+        rows = []
+        error = nil
+
+        begin
+          response = session.execute("#{statement} /*#{comment}*/")
+          rows = response.map { |r| r.values }
+          columns = rows.any? ? response.first.keys : []
+        rescue => e
+          error = e.message
+        end
+
+        [columns, rows, error]
+      end
+
+      def tables
+        session.execute("SELECT table_name FROM system_schema.tables WHERE keyspace_name = '#{keyspace}'").map { |r| r["table_name"] }
+      end
+
+      def schema
+        result = session.execute("SELECT keyspace_name, table_name, column_name, type, position FROM system_schema.columns WHERE keyspace_name = '#{keyspace}'")
+        result.map(&:values).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]} }} }
+      end
+
+      def preview_statement
+        "SELECT * FROM {table} LIMIT 10"
+      end
+
+      private
+
+      def cluster
+        @cluster ||= begin
+          require "cassandra"
+          options = {hosts: [uri.host]}
+          options[:port] = uri.port if uri.port
+          options[:username] = uri.user if uri.user
+          options[:password] = uri.password if uri.password
+          ::Cassandra.cluster(options)
+        end
+      end
+
+      def session
+        @session ||= cluster.connect(keyspace)
+      end
+
+      def uri
+        @uri ||= URI.parse(data_source.settings["url"])
+      end
+
+      def keyspace
+        @keyspace ||= uri.path[1..-1]
+      end
+    end
+  end
+end

data/lib/blazer/adapters/druid_adapter.rb

@@ -0,0 +1,67 @@
+module Blazer
+  module Adapters
+    class DruidAdapter < BaseAdapter
+      TIMESTAMP_REGEX = /\A\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z\z/
+
+      def run_statement(statement, comment)
+        columns = []
+        rows = []
+        error = nil
+
+        header = {"Content-Type" => "application/json", "Accept" => "application/json"}
+        timeout = data_source.timeout ? data_source.timeout.to_i : 300
+        data = {
+          query: statement,
+          context: {
+            timeout: timeout * 1000
+          }
+        }
+
+        uri = URI.parse("#{settings["url"]}/druid/v2/sql/")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.read_timeout = timeout
+
+        begin
+          response = JSON.parse(http.post(uri.request_uri, data.to_json, header).body)
+          if response.is_a?(Hash)
+            error = response["errorMessage"] || "Unknown error: #{response.inspect}"
+            if error.include?("timed out")
+              error = Blazer::TIMEOUT_MESSAGE
+            end
+          else
+            columns = (response.first || {}).keys
+            rows = response.map { |r| r.values }
+
+            # Druid doesn't return column types
+            # and no timestamp type in JSON
+            rows.each do |row|
+              row.each_with_index do |v, i|
+                if v.is_a?(String) && TIMESTAMP_REGEX.match(v)
+                  row[i] = Time.parse(v)
+                end
+              end
+            end
+          end
+         rescue => e
+           error = e.message
+         end
+
+        [columns, rows, error]
+      end
+
+      def tables
+        result = data_source.run_statement("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA NOT IN ('INFORMATION_SCHEMA') ORDER BY TABLE_NAME")
+        result.rows.map(&:first)
+      end
+
+      def schema
+        result = data_source.run_statement("SELECT TABLE_SCHEMA, TABLE_NAME, COLUMN_NAME, DATA_TYPE, ORDINAL_POSITION FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA NOT IN ('INFORMATION_SCHEMA') ORDER BY 1, 2")
+        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]} }} }
+      end
+
+      def preview_statement
+        "SELECT * FROM {table} LIMIT 10"
+      end
+    end
+  end
+end