ruby-grafana-reporter 0.3.0 → 0.4.0

data/lib/grafana/grafana_alerts_datasource.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Grafana
+  # Implements the datasource interface to grafana alerts.
+  class GrafanaAlertsDatasource < AbstractDatasource
+    # +:raw_query+ needs to contain a Hash with the following structure:
+    #
+    #   {
+    #     dashboardId: Dashboard ID as String or nil
+    #     panelId:     Panel ID as String or nil
+    #     columns:
+    #     limit:
+    #     query:
+    #     state:
+    #     folderId:
+    #     dashboardQuery:
+    #     dashboardTag:
+    #   }
+    # @see AbstractDatasource#request
+    def request(query_description)
+      webrequest = query_description[:prepared_request]
+      webrequest.relative_url = "/api/alerts#{url_parameters(query_description)}"
+
+      result = webrequest.execute(query_description[:timeout])
+
+      json = JSON.parse(result.body)
+
+      content = []
+      begin
+        json.each { |item| content << item.fetch_values(*query_description[:raw_query]['columns'].split(',')) }
+      rescue KeyError => e
+        raise MalformedAttributeContentError.new(e.message, 'columns', query_description[:raw_query]['columns'])
+      end
+
+      result = {}
+      result[:header] = [query_description[:raw_query]['columns'].split(',')]
+      result[:content] = content
+
+      result
+    end
+
+    private
+
+    def url_parameters(query_desc)
+      url_vars = {}
+      url_vars.merge!(query_desc[:raw_query].select do |k, _v|
+        k =~ /^(?:limit|dashboardId|panelId|query|state|folderId|dashboardQuery|dashboardTag)/
+      end)
+      url_vars['from'] = query_desc[:from] if query_desc[:from]
+      url_vars['to'] = query_desc[:to] if query_desc[:to]
+      url_params = URI.encode_www_form(url_vars.map { |k, v| [k, v.to_s] })
+      return '' if url_params.empty?
+
+      "?#{url_params}"
+    end
+  end
+end

data/lib/grafana/grafana_annotations_datasource.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Grafana
+  # Implements the datasource interface to grafana annotations.
+  class GrafanaAnnotationsDatasource < AbstractDatasource
+    # +:raw_query+ needs to contain a Hash with the following structure:
+    #
+    #   {
+    #     dashboardId: Dashboard ID as String or nil
+    #     panelId:     Panel ID as String or nil
+    #     columns:
+    #     limit:
+    #     alertId:
+    #     userId:
+    #     type:
+    #     tags:
+    #   }
+    # @see AbstractDatasource#request
+    def request(query_description)
+      webrequest = query_description[:prepared_request]
+      webrequest.relative_url = "/api/annotations#{url_parameters(query_description)}"
+
+      result = webrequest.execute(query_description[:timeout])
+
+      json = JSON.parse(result.body)
+
+      content = []
+      begin
+        json.each { |item| content << item.fetch_values(*query_description[:raw_query]['columns'].split(',')) }
+      rescue KeyError => e
+        raise MalformedAttributeContentError.new(e.message, 'columns', query_description[:raw_query]['columns'])
+      end
+
+      result = {}
+      result[:header] = [query_description[:raw_query]['columns'].split(',')]
+      result[:content] = content
+
+      result
+    end
+
+    private
+
+    def url_parameters(query_desc)
+      url_vars = {}
+      url_vars.merge!(query_desc[:raw_query].select do |k, _v|
+        k =~ /^(?:limit|alertId|dashboardId|panelId|userId|type|tags)/
+      end)
+      url_vars['from'] = query_desc[:from] if query_desc[:from]
+      url_vars['to'] = query_desc[:to] if query_desc[:to]
+      url_params = URI.encode_www_form(url_vars.map { |k, v| [k, v.to_s] })
+      return '' if url_params.empty?
+
+      "?#{url_params}"
+    end
+  end
+end

data/lib/grafana/grafana_property_datasource.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Grafana
+  # Implements the datasource interface to grafana model properties.
+  class GrafanaPropertyDatasource < AbstractDatasource
+    # +:raw_query+ needs to contain a Hash with the following structure:
+    #
+    #   {
+    #     property_name: Name of the queried property as String
+    #     panel:         {Panel} object to query
+    #   }
+    # @see AbstractDatasource#request
+    def request(query_description)
+      raise MissingSqlQueryError if query_description[:raw_query].nil?
+
+      panel = query_description[:raw_query][:panel]
+      property_name = query_description[:raw_query][:property_name]
+
+      {
+        header: [query_description[:raw_query][:property_name]],
+        content: [replace_variables(panel.field(property_name), query_description[:variables])]
+      }
+    end
+  end
+end

data/lib/grafana/graphite_datasource.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Grafana
+  # Implements the interface to graphite datasources.
+  class GraphiteDatasource < AbstractDatasource
+    # +:raw_query+ needs to contain a Graphite query as String
+    # @see AbstractDatasource#request
+    def request(query_description)
+      raise MissingSqlQueryError if query_description[:raw_query].nil?
+
+      request = {
+        body: URI.encode_www_form('from': DateTime.strptime(query_description[:from], '%Q').strftime('%H:%M_%Y%m%d'),
+                                  'until': DateTime.strptime(query_description[:to], '%Q').strftime('%H:%M_%Y%m%d'),
+                                  'format': 'json',
+                                  'target': replace_variables(query_description[:raw_query], query_description[:variables])),
+        content_type: 'application/x-www-form-urlencoded',
+        request: Net::HTTP::Post
+      }
+
+      webrequest = query_description[:prepared_request]
+      webrequest.relative_url = "/api/datasources/proxy/#{id}/render"
+      webrequest.options.merge!(request)
+
+      result = webrequest.execute(query_description[:timeout])
+      preformat_response(result.body)
+    end
+
+    # @see AbstractDatasource#raw_query_from_panel_model
+    def raw_query_from_panel_model(panel_query_target)
+      panel_query_target['target']
+    end
+
+    private
+
+    # @see AbstractDatasource#preformat_response
+    def preformat_response(response_body)
+      # TODO: support multiple metrics as return types
+      {
+        header: %w[value time],
+        content: JSON.parse(response_body).first['datapoints']
+      }
+    end
+  end
+end

data/lib/grafana/image_rendering_datasource.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Grafana
+  # Implements the interface to image rendering datasources.
+  class ImageRenderingDatasource < AbstractDatasource
+    # +:raw_query+ needs to contain a Hash with the following structure:
+    #
+    #   {
+    #     panel: {Panel} which shall be rendered
+    #   }
+    # @see AbstractDatasource#request
+    def request(query_description)
+      webrequest = query_description[:prepared_request]
+      webrequest.relative_url = query_description[:raw_query][:panel].render_url + url_params(query_description)
+      webrequest.options.merge!({ accept: 'image/png' })
+
+      result = webrequest.execute
+
+      { header: ['image'], content: [result.body] }
+    end
+
+    private
+
+    def url_params(query_desc)
+      url_vars = query_desc[:variables].select { |k, _v| k =~ /^(?:timeout|height|width|theme|fullscreen|var-.+)$/ }
+      url_vars = default_vars.merge(url_vars)
+      url_vars['from'] = Variable.new(query_desc[:from])
+      url_vars['to'] = Variable.new(query_desc[:to])
+      result = URI.encode_www_form(url_vars.map { |k, v| [k, v.raw_value.to_s] })
+
+      return '' if result.empty?
+
+      "&#{result}"
+    end
+
+    def default_vars
+      {
+        'fullscreen' => Variable.new(true),
+        'theme' => Variable.new('light'),
+        'timeout' => Variable.new(60)
+      }
+    end
+  end
+end

data/lib/grafana/panel.rb

@@ -5,6 +5,7 @@ module Grafana
   class Panel
     # @return [Dashboard] parent {Dashboard} object
     attr_reader :dashboard
+    attr_reader :model
 
     # @param model [Hash] converted JSON Hash of the panel
     # @param dashboard [Dashboard] parent {Dashboard} object
@@ -25,12 +26,17 @@ module Grafana
       @model['id']
     end
 
-    # @return [String] SQL query string for the requested query letter
+    # @return [Datasource] datasource object specified for the current panel
+    def datasource
+      dashboard.grafana.datasource_by_name(@model['datasource'])
+    end
+
+    # @return [String] query string for the requested query letter
     def query(query_letter)
       query_item = @model['targets'].select { |item| item['refId'].to_s == query_letter.to_s }.first
-      raise QueryLetterDoesNotExistError.new(query_letter, self) if query_item.nil?
+      raise QueryLetterDoesNotExistError.new(query_letter, self) unless query_item
 
-      query_item['rawSql']
+      datasource.raw_query_from_panel_model(query_item)
     end
 
     # @return [String] relative rendering URL for the panel, to create an image out of it

data/lib/grafana/prometheus_datasource.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Grafana
+  # Implements the interface to Prometheus datasources.
+  class PrometheusDatasource < AbstractDatasource
+    # +:raw_query+ needs to contain a Prometheus query as String
+    # @see AbstractDatasource#request
+    def request(query_description)
+      raise MissingSqlQueryError if query_description[:raw_query].nil?
+
+      url = "/api/datasources/proxy/#{id}/api/v1/query_range?"\
+            "start=#{query_description[:from]}&end=#{query_description[:to]}"\
+            "&query=#{replace_variables(query_description[:raw_query], query_description[:variables])}"
+
+      webrequest = query_description[:prepared_request]
+      webrequest.relative_url = url
+      webrequest.options.merge!({ request: Net::HTTP::Get })
+
+      result = webrequest.execute(query_description[:timeout])
+      preformat_response(result.body)
+    end
+
+    # @see AbstractDatasource#raw_query_from_panel_model
+    def raw_query_from_panel_model(panel_query_target)
+      panel_query_target['expr']
+    end
+
+    private
+
+    # @see AbstractDatasource#preformat_response
+    def preformat_response(response_body)
+      # TODO: support multiple metrics as return types
+      {
+        header: %w[time value],
+        content: JSON.parse(response_body)['data']['result'].first['values']
+      }
+    end
+  end
+end

data/lib/grafana/sql_datasource.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Grafana
+  # Implements the interface to all SQL based datasources (tested with PostgreSQL and MariaDB/MySQL).
+  class SqlDatasource < AbstractDatasource
+    # +:raw_query+ needs to contain a SQL query as String in the respective database dialect
+    # @see AbstractDatasource#request
+    def request(query_description)
+      raise MissingSqlQueryError if query_description[:raw_query].nil?
+
+      sql = replace_variables(query_description[:raw_query], query_description[:variables])
+      request = {
+        body: {
+          from: query_description[:from],
+          to: query_description[:to],
+          queries: [rawSql: prepare_sql(sql), datasourceId: id, format: 'table']
+        }.to_json,
+        request: Net::HTTP::Post
+      }
+
+      webrequest = query_description[:prepared_request]
+      webrequest.relative_url = '/api/tsdb/query'
+      webrequest.options.merge!(request)
+
+      result = webrequest.execute(query_description[:timeout])
+      preformat_response(result.body)
+    end
+
+    # @see AbstractDatasource#raw_query_from_panel_model
+    def raw_query_from_panel_model(panel_query_target)
+      panel_query_target['rawSql']
+    end
+
+    private
+
+    def preformat_response(response_body)
+      results = {}
+      results.default = []
+
+      JSON.parse(response_body)['results'].each_value do |query_result|
+        if query_result.key?('error')
+          results[:header] = results[:header] << ['SQL Error']
+          results[:content] = [[query_result['error']]]
+
+        elsif query_result['tables']
+          query_result['tables'].each do |table|
+            results[:header] = results[:header] << table['columns'].map { |header| header['text'] }
+            results[:content] = table['rows']
+          end
+
+        end
+      end
+
+      results
+    end
+
+    def prepare_sql(sql)
+      # remove comments in query
+      sql.gsub!(/--[^\r\n]*(?:[\r\n]+|$)/, ' ')
+      sql.gsub!(/\r\n/, ' ')
+      sql.gsub!(/\n/, ' ')
+      sql
+    end
+  end
+end

data/lib/grafana/variable.rb

@@ -10,6 +10,7 @@ module Grafana
   class Variable
     attr_reader :name, :text, :raw_value
 
+    # Translation table to support {https://momentjs.com/docs/#/displaying/}.
     DATE_MATCHES = { 'M' => '%-m', 'MM' => '%m', 'MMM' => '%b',  'MMMM' => '%B',
                      'D' => '%-d', 'DD' => '%d', 'DDD' => '%-j', 'DDDD' => '%j',
                      'd' => '%w',                'ddd' => '%a',  'dddd' => '%A',

data/lib/grafana/webrequest.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Grafana
+  # This class standardizes all webcalls. Key functionality is to properly support HTTPS calls as a base functionality.
+  class WebRequest
+    attr_accessor :relative_url, :options
+
+    @ssl_cert = nil
+
+    class << self
+      attr_accessor :ssl_cert
+    end
+
+    # Initializes a specific HTTP request.
+    #
+    # Default (can be overridden, by specifying the options Hash):
+    #   accept: 'application/json'
+    #   request: Net::HTTP::Get
+    #   content_type: 'application/json'
+    #
+    # @param base_url [String] URL which shall be queried
+    # @param options [Hash] options, which shall be merged to the request. Also allows `+logger+` option
+    def initialize(base_url, options = {})
+      @base_url = base_url
+      default_options = { accept: 'application/json', request: Net::HTTP::Get, content_type: 'application/json' }
+      @options = default_options.merge(options.reject { |k, _v| k == :logger && k == :relative_url })
+      @relative_url = options[:relative_url]
+      @logger = options[:logger] || Logger.new(nil)
+    end
+
+    # Executes the HTTP request
+    #
+    # @param timeout [Integer] number of seconds to wait, before the http request is cancelled, defaults to 60 seconds
+    # @return [Response] HTTP response object
+    def execute(timeout = nil)
+      timeout ||= 60
+
+      uri = URI.parse("#{@base_url}#{@relative_url}")
+      @http = Net::HTTP.new(uri.host, uri.port)
+      configure_ssl if @base_url =~ /^https/
+
+      @http.read_timeout = timeout.to_i
+
+      request = @options[:request].new(uri.request_uri)
+      request['Accept'] = @options[:accept] if @options[:accept]
+      request['Content-Type'] = @options[:content_type] if @options[:content_type]
+      request['Authorization'] = @options[:authorization] if @options[:authorization]
+      request.body = @options[:body]
+
+      @logger.debug("Requesting #{uri} with '#{@options[:body]}' and timeout '#{timeout}'")
+      response = @http.request(request)
+      @logger.debug("Received response #{response}")
+
+      response
+    end
+
+    private
+
+    def configure_ssl
+      @http.use_ssl = true
+      @http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      if self.class.ssl_cert && !File.exist?(self.class.ssl_cert)
+        @logger.warn('SSL certificate file does not exist.')
+      elsif self.class.ssl_cert
+        @http.cert_store = OpenSSL::X509::Store.new
+        @http.cert_store.set_default_paths
+        @http.cert_store.add_file(self.class.ssl_cert)
+      end
+    end
+  end
+end