ruby-grafana-reporter 0.3.0 → 0.4.4

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,37 @@
+# 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]
+
+      return "Panel property '#{property_name}' does not exist for panel '#{panel.id}'" unless panel.field(property_name)
+
+      {
+        header: [query_description[:raw_query][:property_name]],
+        content: [replace_variables(panel.field(property_name), query_description[:variables])]
+      }
+    end
+
+    # @see AbstractDatasource#default_variable_format
+    def default_variable_format
+      'glob'
+    end
+
+    # @see AbstractDatasource#name
+    def name
+      self.class.to_s
+    end
+  end
+end

data/lib/grafana/graphite_datasource.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Grafana
+  # Implements the interface to graphite datasources.
+  class GraphiteDatasource < AbstractDatasource
+    # @see AbstractDatasource#handles?
+    def self.handles?(model)
+      tmp = new(model)
+      tmp.type == 'graphite'
+    end
+
+    # +: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
+
+    # @see AbstractDatasource#default_variable_format
+    def default_variable_format
+        'glob'
+    end
+
+    private
+
+    # @see AbstractDatasource#preformat_response
+    def preformat_response(response_body)
+      json = JSON.parse(response_body)
+
+      header = ['time']
+      content = {}
+
+      # keep sorting, if json has only one target item, otherwise merge results and return
+      # as a time sorted array
+      return { header: header << json.first['target'], content: json.first['datapoints'].map! { |item| [item[1], item[0]] } } if json.length == 1
+
+      # TODO: show warning if results may be sorted different
+      json.each_index do |i|
+        header << json[i]['target']
+        tmp = json[i]['datapoints'].map! { |item| [item[1], item[0]] }.to_h
+        tmp.each_key { |key| content[key] = Array.new(json.length) unless content[key] }
+
+        content.merge!(tmp) do |_key, old, new|
+          old[i] = new
+          old
+        end
+      end
+
+      { header: header, content: content.to_a.map(&:flatten).sort { |a, b| a[0] <=> b[0] } }
+    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/influxdb_datasource.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Grafana
+  # Implements the interface to Prometheus datasources.
+  class InfluxDbDatasource < AbstractDatasource
+    # @see AbstractDatasource#handles?
+    def self.handles?(model)
+      tmp = new(model)
+      tmp.type == 'influxdb'
+    end
+
+    # +:database+ needs to contain the InfluxDb database name
+    # +:raw_query+ needs to contain a InfluxDb query as String
+    # @see AbstractDatasource#request
+    def request(query_description)
+      raise MissingSqlQueryError if query_description[:raw_query].nil?
+
+      url = "/api/datasources/proxy/#{id}/query?db=#{@model['database']}&q=#{ERB::Util.url_encode(query_description[:raw_query])}&epoch=ms"
+
+      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)
+      return panel_query_target['query'] if panel_query_target['rawQuery']
+
+      # TODO: support composed queries
+      raise ComposedQueryNotSupportedError, self
+    end
+
+    # @see AbstractDatasource#default_variable_format
+    def default_variable_format
+      'regex'
+    end
+
+    private
+
+    # @see AbstractDatasource#preformat_response
+    def preformat_response(response_body)
+      # TODO: how to handle multiple query results?
+      json = JSON.parse(response_body)['results'].first['series']
+
+      header = ['time']
+      content = {}
+
+      # keep sorting, if json has only one target item, otherwise merge results and return
+      # as a time sorted array
+      return { header: header << "#{json.first['name']} #{json.first['columns'][1]} (#{json.first['tags']})", content: json.first['values'] } if json.length == 1
+
+      # TODO: show warning here, as results may be sorted different
+      json.each_index do |i|
+        header << "#{json[i]['name']} #{json[i]['columns'][1]} (#{json[i]['tags']})"
+        tmp = json[i]['values'].to_h
+        tmp.each_key { |key| content[key] = Array.new(json.length) unless content[key] }
+
+        content.merge!(tmp) do |_key, old, new|
+          old[i] = new
+          old
+        end
+      end
+
+      { header: header, content: content.to_a.map(&:flatten).sort { |a, b| a[0] <=> b[0] } }
+    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
@@ -17,7 +18,7 @@ module Grafana
     def field(field)
       return @model[field] if @model.key?(field)
 
-      ''
+      nil
     end
 
     # @return [String] panel ID
@@ -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,67 @@
+# frozen_string_literal: true
+
+module Grafana
+  # Implements the interface to Prometheus datasources.
+  class PrometheusDatasource < AbstractDatasource
+    # @see AbstractDatasource#handles?
+    def self.handles?(model)
+      tmp = new(model)
+      tmp.type == 'prometheus'
+    end
+
+    # +: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
+
+    # @see AbstractDatasource#default_variable_format
+    def default_variable_format
+        'regex'
+    end
+
+    private
+
+    # @see AbstractDatasource#preformat_response
+    def preformat_response(response_body)
+      json = JSON.parse(response_body)['data']['result']
+
+      headers = ['time']
+      content = {}
+
+      # keep sorting, if json has only one target item, otherwise merge results and return
+      # as a time sorted array
+      return { header: headers << json.first['metric']['mode'], content: json.first['values'] } if json.length == 1
+
+      # TODO: show warning if results may be sorted different
+      json.each_index do |i|
+        headers += [json[i]['metric']['mode']]
+        tmp = json[i]['values'].to_h
+        tmp.each_key { |key| content[key] = Array.new(json.length) unless content[key] }
+
+        content.merge!(tmp) do |_key, old, new|
+          old[i] = new
+          old
+        end
+      end
+
+      { header: headers, content: content.to_a.map(&:flatten).sort { |a, b| a[0] <=> b[0] } }
+    end
+  end
+end

data/lib/grafana/sql_datasource.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Grafana
+  # Implements the interface to all SQL based datasources (tested with PostgreSQL and MariaDB/MySQL).
+  class SqlDatasource < AbstractDatasource
+    # @see AbstractDatasource#handles?
+    def self.handles?(model)
+      tmp = new(model)
+      tmp.category == 'sql'
+    end
+
+    # +: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: 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
+
+    # Currently all composed SQL queries are saved in the dashboard as rawSql, so no conversion
+    # necessary here.
+    # @see AbstractDatasource#raw_query_from_panel_model
+    def raw_query_from_panel_model(panel_query_target)
+      panel_query_target['rawSql']
+    end
+
+    # @see AbstractDatasource#default_variable_format
+    def default_variable_format
+        'glob'
+    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
+  end
+end