ruby-grafana-reporter 0.2.0 → 0.4.1

data/lib/grafana/errors.rb

@@ -57,10 +57,17 @@ module Grafana
     end
   end
 
-  # Raised if no SQL query is specified in a {AbstractSqlQuery} object.
+  # Raised if no SQL query is specified.
   class MissingSqlQueryError < GrafanaError
     def initialize
       super('No SQL statement has been specified.')
     end
   end
+
+  # Raised if a datasource shall be queried, which is not (yet) supported by the reporter
+  class InvalidDatasourceQueryProvidedError < GrafanaError
+    def initialize(query)
+      super("The datasource query provided, does not look like a grafana datasource target (received: #{query}).")
+    end
+  end
 end

data/lib/grafana/grafana.rb

@@ -9,20 +9,20 @@
 module Grafana
   # Main class for handling the interaction with one specific Grafana instance.
   class Grafana
+    attr_reader :logger
+
     # @param base_uri [String] full URI pointing to the specific grafana instance without
     #   trailing slash, e.g. +https://localhost:3000+.
     # @param key [String] API key for the grafana instance, if required
     # @param opts [Hash] additional options.
-    #   Currently supporting +:logger+ and +:datasources+.
-    #   +:datasources+ need to be an Hash with datasource name as key and datasource id as value.
-    #   If not specified, the datasources will be queried from the grafana interface.
-    #   Specifying +:datasources+> here can be used, so that the interface can be used without grafana Admin privileges.
+    #   Currently supporting +:logger+.
     def initialize(base_uri, key = nil, opts = {})
       @base_uri = base_uri
       @key = key
       @dashboards = {}
       @logger = opts[:logger] || ::Logger.new(nil)
-      @datasources = opts[:datasources]
+
+      initialize_datasources unless @base_uri.empty?
     end
 
     # Used to test a connection to the grafana instance.
@@ -32,34 +32,52 @@ module Grafana
     #
     # @return [String] +Admin+, +NON-Admin+ or +Failed+ is returned, depending on the test results
     def test_connection
-      if execute_http_request('/api/datasources').is_a?(Net::HTTPOK)
+      if prepare_request({ relative_url: '/api/datasources' }).execute.is_a?(Net::HTTPOK)
         # we have admin rights
-        @logger.info('Reporter is running with Admin privileges on grafana.')
+        @logger.warn('Reporter is running with Admin privileges on grafana. This is a potential security risk.')
         return 'Admin'
       end
       # check if we have lower rights
-      return 'Failed' unless execute_http_request('/api/dashboards/home').is_a?(Net::HTTPOK)
+      return 'Failed' unless prepare_request({ relative_url: '/api/dashboards/home' }).execute.is_a?(Net::HTTPOK)
 
-      @logger.warn('Reporter is running with NON-Admin privileges on grafana. Make sure that necessary'\
-                   'datasources are specified in CONFIG_FILE, otherwise operation will fail')
+      @logger.info('Reporter is running with NON-Admin privileges on grafana.')
       'NON-Admin'
     end
 
-    # Returns the ID of a datasource, which has been queried by the datasource name.
+    # Returns the datasource, which has been queried by the datasource name.
     #
-    # @return [Integer] ID for the specified datasource name
-    def datasource_id(datasource_name)
-      id = datasources[datasource_name]
-      raise DatasourceDoesNotExistError.new('name', datasource_name) unless id
+    # @param datasource_name [String] name of the searched datasource
+    # @return [Datasource] Datasource for the specified datasource name
+    def datasource_by_name(datasource_name)
+      datasource_name = 'default' if datasource_name.to_s.empty?
+      raise DatasourceDoesNotExistError.new('name', datasource_name) unless @datasources[datasource_name]
 
-      id
+      @datasources[datasource_name]
     end
 
-    # Returns if the given datasource ID exists for the grafana instance.
+    # Returns the datasource, which has been queried by the datasource id.
     #
-    # @return [Boolean] true if exists, false otherwise
-    def datasource_id_exists?(datasource_id)
-      datasources.value?(datasource_id)
+    # @param datasource_id [Integer] id of the searched datasource
+    # @return [Datasource] Datasource for the specified datasource id
+    def datasource_by_id(datasource_id)
+      datasource = @datasources.select { |_name, ds| ds.id == datasource_id.to_i }.values.first
+      raise DatasourceDoesNotExistError.new('id', datasource_id) unless datasource
+
+      datasource
+    end
+
+    # @return [Array] Array of dashboard uids within the current grafana object
+    def dashboard_ids
+      response = prepare_request({ relative_url: '/api/search' }).execute
+      return [] unless response.is_a?(Net::HTTPOK)
+
+      dashboards = JSON.parse(response.body)
+
+      dashboards.each do |dashboard|
+        @dashboards[dashboard['uid']] = nil unless @dashboards[dashboard['uid']]
+      end
+
+      @dashboards.keys
     end
 
     # @param dashboard_uid [String] UID of the searched {Dashboard}
@@ -67,64 +85,42 @@ module Grafana
     def dashboard(dashboard_uid)
       return @dashboards[dashboard_uid] unless @dashboards[dashboard_uid].nil?
 
-      response = execute_http_request("/api/dashboards/uid/#{dashboard_uid}")
-      model = JSON.parse(response.body)['dashboard']
-
-      raise DashboardDoesNotExistError, dashboard_uid if model.nil?
+      response = prepare_request({ relative_url: "/api/dashboards/uid/#{dashboard_uid}" }).execute
+      raise DashboardDoesNotExistError, dashboard_uid unless response.is_a?(Net::HTTPOK)
 
       # cache dashboard for reuse
+      model = JSON.parse(response.body)['dashboard']
       @dashboards[dashboard_uid] = Dashboard.new(model, self)
 
       @dashboards[dashboard_uid]
     end
 
-    # Runs a specific HTTP request against the current grafana instance.
+    # Prepares a {WebRequest} object for the current {Grafana} instance, which may be enriched
+    # with further properties and can then run {WebRequest#execute}.
     #
-    # Default (can be overridden, by specifying the options Hash):
-    #   accept: 'application/json'
-    #   request: Net::HTTP::Get
-    #   content_type: 'application/json'
-    #
-    # @param relative_uri [String] relative URL with a leading slash, which shall be queried
-    # @param options [Hash] options, which shall be merged to the request.
-    # @param timeout [Integer] number of seconds to wait, before the http request is cancelled, defaults to 60 seconds
-    def execute_http_request(relative_uri, options = {}, timeout = nil)
-      uri = URI.parse(@base_uri + relative_uri)
-      default_options = { accept: 'application/json', request: Net::HTTP::Get, content_type: 'application/json' }
-      options = default_options.merge(options)
-
-      http = Net::HTTP.new(uri.host, uri.port)
-      if @base_uri =~ /^https/
-        http.use_ssl = true
-        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-      end
-      http.read_timeout = timeout.to_i if timeout
-
-      request = options[:request].new(uri.request_uri)
-      request['Accept'] = options[:accept]
-      request['Content-Type'] = options[:content_type]
-      request['Authorization'] = "Bearer #{@key}" unless @key.nil?
-      request.body = options[:body]
-
-      @logger.debug("Requesting #{relative_uri} with '#{options[:body]}' and timeout '#{http.read_timeout}'")
-      http.request(request)
+    # @option options [Hash] :relative_url relative URL with a leading slash, which shall be queried
+    # @option options [Hash] :accept
+    # @option options [Hash] :body
+    # @option options [Hash] :content_type
+    # @return [WebRequest] webrequest prepared for execution
+    def prepare_request(options = {})
+      auth = @key ? { authorization: "Bearer #{@key}" } : {}
+      WebRequest.new(@base_uri, auth.merge({ logger: @logger }).merge(options))
     end
 
     private
 
-    def datasources
-      if @datasources.nil?
-        # load datasources from grafana directly, if allowed
-        response = execute_http_request('/api/datasources')
-        if response['message'].nil?
-          json = JSON.parse(response.body)
-          # only store needed values
-          @datasources = json.map { |item| [item['name'], item['id']] }.to_h
-        else
-          @datasources = {}
-        end
+    def initialize_datasources
+      @datasources = {}
+
+      settings = prepare_request({ relative_url: '/api/frontend/settings' }).execute
+      return unless settings.is_a?(Net::HTTPOK)
+
+      json = JSON.parse(settings.body)
+      json['datasources'].select { |_k, v| v['id'].to_i.positive? }.each do |ds_name, ds_value|
+        @datasources[ds_name] = AbstractDatasource.build_instance(ds_value)
       end
-      @datasources
+      @datasources['default'] = @datasources[json['defaultDatasource']]
     end
   end
 end

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,50 @@
+# 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
+
+    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