ruby-grafana-reporter 0.4.5 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd6bdf1a9856b3c0a663060c4b2ecfc3a094ae230635807398a611d38d74ac90
-  data.tar.gz: 95ac2750e962a67b0d3b71184b5409b88441840f4b08f31284b33f20b0d862a3
+  metadata.gz: de6063d128d57f930e83b17253e34e4e20624ef796e7eb86df2e7d54bee7825c
+  data.tar.gz: a6a5f8b3bfcdcfc557ede19e7d89a25de8dca277806da0f662c4165d0a05b03c
 SHA512:
-  metadata.gz: 53698b98b33afef1706243cf5c322bd1a9968ec723e18d32ec5d550769117fa9c64c43c9d174752630ac7f8e8015d1394d4f2060fbe6be1b2ce73d7ad8390801
-  data.tar.gz: 5f39c12e056e689ff442f00c175219e6a560e9e38362a5aec9f67dc738b172ebf0b9d288958e312020f8304603e54ff1c4e21ca44d77182342a3df9fe03825ba
+  metadata.gz: c9338b1dbd16a81af0c28feb9e8f4efd576ffb3f879aae7dd5d31b00468b32cc18ee49e7a73f87e952e2781845cd1d54124512aef6112194379d3840322fbff8
+  data.tar.gz: 01bed067acfc6442e62ba17dbda3491e6147778a274c65ccacc7f838e57beda53809e8a8b827fad09266b4b506c2e29d7e8d3b0670c506eb0063eddd40d1aa26

data/README.md

@@ -30,7 +30,7 @@ professional reporting functionality. And this is, where the ruby grafana report
 steps in.
 
 The key functionality of the reporter is to capture data and images from grafana
-dashboards and to use it in your custom templates to finally create reports in PDF
+dashboards and to use it in your custom templates to finally create reports in PDF
 (default), HTML, or any other format.
 
 By default (an extended version of) Asciidoctor is enabled as template language.
@@ -65,7 +65,7 @@ Database                  | Image rendering | Raw queries   | Composed queries
 ------------------------- | :-------------: | :-----------: | :------------:
 all SQL based datasources | supported       | supported     | supported
 Graphite                  | supported       | supported     | supported
-InfluxDB                  | supported       | supported     | not (yet) supported
+InfluxDB                  | supported       | supported     | supported
 Prometheus                | supported       | supported     | n/a in grafana
 other datasources         | supported       | not supported | not supported
 

data/lib/VERSION.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 # Version information
-GRAFANA_REPORTER_VERSION = [0, 4, 5].freeze
+GRAFANA_REPORTER_VERSION = [0, 5, 2].freeze
 # Release date
-GRAFANA_REPORTER_RELEASE_DATE = '2021-08-26'
+GRAFANA_REPORTER_RELEASE_DATE = '2022-03-22'

data/lib/grafana/abstract_datasource.rb

@@ -57,6 +57,11 @@ module Grafana
       @model['name']
     end
 
+    # @return [String] unique ID of the datasource
+    def uid
+      @model['uid']
+    end
+
     # @return [Integer] ID of the datasource
     def id
       @model['id'].to_i
@@ -128,6 +133,9 @@ module Grafana
         repeat_count += 1
 
         variables.each do |name, variable|
+          # do not replace with non grafana variables
+          next unless name =~ /^var-/
+
           # only set ticks if value is string
           var_name = name.gsub(/^var-/, '')
           next unless var_name =~ /^\w+$/

data/lib/grafana/dashboard.rb

@@ -35,6 +35,11 @@ module Grafana
       @model['uid']
     end
 
+    # @return [String] dashboard title
+    def title
+      @model['title']
+    end
+
     # @return [Panel] panel for the specified ID
     def panel(id)
       panels = @panels.select { |item| item.field('id') == id.to_i }
@@ -53,7 +58,7 @@ module Grafana
       list = @model['templating']['list']
       return unless list.is_a? Array
 
-      list.each { |item| @variables << Variable.new(item) }
+      list.each { |item| @variables << Variable.new(item, self) }
     end
 
     # read panels

data/lib/grafana/errors.rb

@@ -53,7 +53,8 @@ module Grafana
   class ImageCouldNotBeRenderedError < GrafanaError
     def initialize(panel)
       super("The specified panel '#{panel.id}' from dashboard '#{panel.dashboard.id}' could not be "\
-        'rendered to an image.')
+        'rendered to an image. Check if rendering is possible manually by selecting "Share" and then '\
+        '"Direct link rendered image" from a panel\'s options menu.')
     end
   end
 
@@ -70,4 +71,11 @@ module Grafana
       super("The datasource query provided, does not look like a grafana datasource target (received: #{query}).")
     end
   end
+
+  # Raised if a datasource query returned with an unsupported result
+  class UnsupportedQueryResponseReceivedError < GrafanaError
+    def initialize(response)
+      super("The datasource request returned with an unsupported response format (received: #{response}).")
+    end
+  end
 end

data/lib/grafana/grafana.rb

@@ -25,6 +25,30 @@ module Grafana
       initialize_datasources unless @base_uri.empty?
     end
 
+    # @return [Hash] Information about the current organization
+    def organization
+      return @organization if @organization
+
+      response = prepare_request({ relative_url: '/api/org/' }).execute
+      if response.is_a?(Net::HTTPOK)
+        @organization = JSON.parse(response.body)
+      end
+
+      @organization
+    end
+
+    # @return [String] grafana version
+    def version
+      return @version if @version
+
+      response = prepare_request({ relative_url: '/api/health' }).execute
+      if response.is_a?(Net::HTTPOK)
+        @version = JSON.parse(response.body)['version']
+      end
+
+      @version
+    end
+
     # Used to test a connection to the grafana instance.
     #
     # Running this function also determines, if the API configured here has Admin or NON-Admin privileges,
@@ -57,6 +81,17 @@ module Grafana
       @datasources[datasource_name]
     end
 
+    # Returns the datasource, which has been queried by the datasource uid.
+    #
+    # @param datasource_uid [String] unique id of the searched datasource
+    # @return [Datasource] Datasource for the specified datasource unique id
+    def datasource_by_uid(datasource_uid)
+      datasource = @datasources.select { |_name, ds| ds.uid == datasource_uid }.values.first
+      raise DatasourceDoesNotExistError.new('uid', datasource_uid) unless datasource
+
+      datasource
+    end
+
     # Returns the datasource, which has been queried by the datasource id.
     #
     # @param datasource_id [Integer] id of the searched datasource

data/lib/grafana/grafana_environment_datasource.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Grafana
+  # Implements a datasource to return environment related information about the grafana instance in a tabular format.
+  class GrafanaEnvironmentDatasource < ::Grafana::AbstractDatasource
+    # +:raw_query+ needs to contain a Hash with the following structure:
+    #
+    #   {
+    #     grafana:  {Grafana} object to query
+    #     mode:     'general' (default) or 'dashboards' for receiving different environment information
+    #   }
+    # @see AbstractDatasource#request
+    def request(query_description)
+      raise MissingSqlQueryError if query_description[:raw_query].nil?
+      raw_query = {mode: 'general'}.merge(query_description[:raw_query])
+
+      return dashboards_data(raw_query[:grafana]) if raw_query[:mode] == 'dashboards'
+
+      general_data(raw_query[:grafana])
+    end
+
+    # @see AbstractDatasource#default_variable_format
+    def default_variable_format
+      nil
+    end
+
+    # @see AbstractDatasource#name
+    def name
+      self.class.to_s
+    end
+
+    private
+
+    def general_data(grafana)
+      {
+        header: ['Version', 'Organization Name', 'Organization ID', 'Access permissions'],
+        content: [[grafana.version,
+                   grafana.organization['name'],
+                   grafana.organization['id'],
+                   grafana.test_connection]]
+      }
+    end
+
+    def dashboards_data(grafana)
+      content = []
+      grafana.dashboard_ids.each do |id|
+        content << [id, grafana.dashboard(id).title, grafana.dashboard(id).panels.length]
+      end
+
+      {
+        header: ['Dashboard ID', 'Dashboard Name', '# Panels'],
+        content: content
+      }
+    end
+  end
+end

data/lib/grafana/graphite_datasource.rb

@@ -47,6 +47,9 @@ module Grafana
     def preformat_response(response_body)
       json = JSON.parse(response_body)
 
+      raise UnsupportedQueryResponseReceivedError, response_body if json.first['target'].nil?
+      raise UnsupportedQueryResponseReceivedError, response_body if json.first['datapoints'].nil?
+
       header = ['time']
       content = {}
 

data/lib/grafana/image_rendering_datasource.rb

@@ -10,12 +10,16 @@ module Grafana
     #   }
     # @see AbstractDatasource#request
     def request(query_description)
+      panel = query_description[:raw_query][:panel]
+
       webrequest = query_description[:prepared_request]
-      webrequest.relative_url = query_description[:raw_query][:panel].render_url + url_params(query_description)
+      webrequest.relative_url = panel.render_url + url_params(query_description)
       webrequest.options.merge!({ accept: 'image/png' })
 
       result = webrequest.execute
 
+      raise ImageCouldNotBeRenderedError, panel if result.body.include?('<html')
+
       { header: ['image'], content: [result.body] }
     end
 

data/lib/grafana/influxdb_datasource.rb

@@ -23,11 +23,13 @@ module Grafana
       # replace $timeFilter variable
       query = query.gsub(/\$timeFilter(?=\W|$)/, "time >= #{query_description[:from]}ms and time <= #{query_description[:to]}ms")
 
+      interval = query_description[:variables].delete('interval') || ((query_description[:to].to_i - query_description[:from].to_i) / 1000).to_i
+      interval = interval.raw_value if interval.is_a?(Variable)
+
       # replace grafana variables $__interval and $__interval_ms in query
-      # TODO: influx datasource currently uses a fixed values of 1000 width for interval variables specified in a query - it should be possible to calculate this according to grafana
       # TODO: check where calculation and replacement of interval variable should take place
-      query = query.gsub(/\$(?:__)?interval(?=\W|$)/, "#{((query_description[:to].to_i - query_description[:from].to_i) / 1000 / 1000).to_i}s")
-      query = query.gsub(/\$(?:__)?interval_ms(?=\W|$)/, "#{((query_description[:to].to_i - query_description[:from].to_i) / 1000).to_i}")
+      query = query.gsub(/\$(?:__)?interval(?=\W|$)/, "#{interval.is_a?(String) ? interval : "#{(interval / 1000).to_i}s"}")
+      query = query.gsub(/\$(?:__)?interval_ms(?=\W|$)/, "#{interval}")
 
       url = "/api/datasources/proxy/#{id}/query?db=#{@model['database']}&q=#{ERB::Util.url_encode(query)}&epoch=ms"
 
@@ -128,7 +130,12 @@ module Grafana
     # @see AbstractDatasource#preformat_response
     def preformat_response(response_body)
       # TODO: how to handle multiple query results?
-      json = JSON.parse(response_body)['results'].first['series']
+      json = JSON.parse(response_body)
+      raise UnsupportedQueryResponseReceivedError, response_body if json['results'].nil?
+      raise UnsupportedQueryResponseReceivedError, response_body if json['results'].first.nil?
+      raise UnsupportedQueryResponseReceivedError, response_body if json['results'].first['series'].nil?
+
+      json = json['results'].first['series']
       return {} if json.nil?
 
       header = ['time']

data/lib/grafana/panel.rb

@@ -28,7 +28,11 @@ module Grafana
 
     # @return [Datasource] datasource object specified for the current panel
     def datasource
-      dashboard.grafana.datasource_by_name(@model['datasource'])
+      if @model['datasource'].is_a?(Hash)
+        dashboard.grafana.datasource_by_uid(@model['datasource']['uid'])
+      else
+        dashboard.grafana.datasource_by_name(@model['datasource'])
+      end
     end
 
     # @return [String] query string for the requested query letter

data/lib/grafana/prometheus_datasource.rb

@@ -14,13 +14,25 @@ module Grafana
     def request(query_description)
       raise MissingSqlQueryError if query_description[:raw_query].nil?
 
-      # TODO: properly allow endpoint to be set - also check raw_query method
-      end_point = @endpoint ? @endpoint : "query_range"
+      query_hash = query_description[:raw_query].is_a?(Hash) ? query_description[:raw_query] : {}
 
-      # TODO: set query option 'step' on request
-      url = "/api/datasources/proxy/#{id}/api/v1/#{end_point}?"\
-            "start=#{query_description[:from]}&end=#{query_description[:to]}"\
-            "&query=#{replace_variables(query_description[:raw_query], query_description[:variables])}"
+      # read instant value and convert instant value to boolean value
+      instant = query_description[:variables].delete('instant') || query_hash[:instant] || false
+      instant = instant.raw_value if instant.is_a?(Variable)
+      instant = instant.to_s.downcase == 'true'
+      interval = query_description[:variables].delete('interval') || query_hash[:interval] || 15
+      interval = interval.raw_value if interval.is_a?(Variable)
+      query = query_hash[:query] || query_description[:raw_query]
+
+      url = if instant
+        "/api/datasources/proxy/#{id}/api/v1/query?time=#{query_description[:to]}&query="\
+        "#{CGI.escape(replace_variables(query, query_description[:variables]))}"
+      else
+        "/api/datasources/proxy/#{id}/api/v1/query_range?start=#{query_description[:from]}"\
+        "&end=#{query_description[:to]}"\
+        "&query=#{CGI.escape(replace_variables(query, query_description[:variables]))}"\
+        "&step=#{interval}"
+      end
 
       webrequest = query_description[:prepared_request]
       webrequest.relative_url = url
@@ -32,8 +44,8 @@ module Grafana
 
     # @see AbstractDatasource#raw_query_from_panel_model
     def raw_query_from_panel_model(panel_query_target)
-      @endpoint = panel_query_target['format'] == 'time_series' && (panel_query_target['instant'] == false || !panel_query_target['instant']) ? 'query_range' : 'query'
-      panel_query_target['expr']
+      { query: panel_query_target['expr'], instant: panel_query_target['instant'],
+        interval: panel_query_target['step'] }
     end
 
     # @see AbstractDatasource#default_variable_format
@@ -45,16 +57,64 @@ module Grafana
 
     # @see AbstractDatasource#preformat_response
     def preformat_response(response_body)
-      json = JSON.parse(response_body)['data']['result']
+      json = {}
+      begin
+        json = JSON.parse(response_body)
+      rescue
+        raise UnsupportedQueryResponseReceivedError, response_body
+      end
+
+      # handle response with error result
+      unless json['error'].nil?
+        return { header: ['error'], content: [[ json['error'] ]] }
+      end
+
+      # handle dataframes
+      if json['results']
+        data = json['results'].values.first
+        raise UnsupportedQueryResponseReceivedError, response_body if data.nil?
+        raise UnsupportedQueryResponseReceivedError, response_body if data['frames'].nil?
+        # TODO: check how multiple frames have to be handled
+
+        data = data['frames']
+        headers = []
+        data.first['schema']['fields'].each do |headline|
+          header = headline['config']['displayNameFromDS'].nil? ? headline['name'] : headline['config']['displayNameFromDS']
+          headers << header
+        end
+        content = data.first['data']['values'][0].zip(data.first['data']['values'][1])
+        return { header: headers, content: content }
+      end
+
+      # handle former result formats
+      raise UnsupportedQueryResponseReceivedError, response_body if json['data'].nil?
+      raise UnsupportedQueryResponseReceivedError, response_body if json['data']['resultType'].nil?
+      raise UnsupportedQueryResponseReceivedError, response_body if json['data']['result'].nil?
+
+      result_type = json['data']['resultType']
+      json = json['data']['result']
+
+      raise UnsupportedQueryResponseReceivedError, response_body if not result_type =~ /^(?:scalar|string|vector|matrix)$/
 
       headers = ['time']
       content = {}
 
+      # handle vector queries
+      if result_type == 'vector'
+        return {
+          header: (headers << 'value') + json.first['metric'].keys,
+          content: [ [json.first['value'][0], json.first['value'][1]] + json.first['metric'].values ]
+        }
+      end
+
+      # handle scalar queries
+      if result_type =~ /^(?:scalar|string)$/
+        return { header: headers << result_type, content: [[json[0], json[1]]] }
+      end
+
       # keep sorting, if json has only one target item, otherwise merge results and return
       # as a time sorted array
-      # TODO properly set headlines
       if json.length == 1
-        return { header: headers << json.first['metric'].to_s, content: [[json.first['value'][1], json.first['value'][0]]] } if json.first.has_key?('value') # this happens for the special case of calls to '/query' endpoint
         return { header: headers << json.first['metric']['mode'], content: json.first['values'] }
       end
 

data/lib/grafana/sql_datasource.rb

@@ -49,18 +49,24 @@ module Grafana
     def preformat_response(response_body)
       results = {}
       results.default = []
+      results[:header] = []
+      results[:content] = []
 
       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']
+        elsif query_result.key?('tables')
+          if 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
 
+        else
+          raise UnsupportedQueryResponseReceivedError, response_body
         end
       end
 

data/lib/grafana/variable.rb

@@ -29,15 +29,14 @@ module Grafana
 
     # @param config_or_value [Hash, Object] configuration hash of a variable out of an {Dashboard} instance
     #  or a value of any kind.
-    def initialize(config_or_value)
+    # @param dashboard [Dashboard] parent dashboard, if applicable; especially needed for query variable
+    #  evaluation.
+    def initialize(config_or_value, dashboard = nil)
       if config_or_value.is_a? Hash
+        @dashboard = dashboard
         @config = config_or_value
         @name = @config['name']
-        # TODO: if a variable uses type 'query' which is never updated, the selected values are stored in 'options'
-        unless @config['current'].nil?
-          @raw_value = @config['current']['value']
-          @text = @config['current']['text']
-        end
+        init_values
       else
         @config = {}
         @raw_value = config_or_value
@@ -68,14 +67,19 @@ module Grafana
       if value == '$__all'
         if !@config['options'].empty?
           # this query contains predefined values, so capture them and format the values accordingly
-          # this happens either if type='custom' or a query, which is never updated
-          value = @config['options'].map { |item| item['value'] }
+          # this happens either for type='custom' or type 'query', if it is never updated
+          value = @config['options'].reject { |item| item['value'] == '$__all' }.map { |item| item['value'] }
 
         elsif @config['type'] == 'query' && !@config['query'].empty?
-          # TODO: replace variables in query, execute it and evaluate the results as if they were normally selected
-          # "multiFormat": contains variable replacement in "query", e.g. 'regex values' or 'glob'
-          # "datasource": contains name of datasource
-          return @config['query']
+          # variables in this configuration are not stored in grafana, i.e. if all is selected here,
+          # the values have to be fetched from the datasource
+          query = ::GrafanaReporter::QueryValueQuery.new(@dashboard)
+          query.datasource = @dashboard.grafana.datasource_by_name(@config['datasource'])
+          query.variables['result_type'] = Variable.new('object')
+          query.raw_query = @config['query']
+          result = query.execute
+
+          value = result[:content].map { |item| item[0].to_s }
 
         else
           # TODO: add support for variable type: 'datasource' and 'adhoc'
@@ -149,8 +153,10 @@ module Grafana
         value.gsub(%r{[" |=/\\]}, '\\\\\0')
 
       when /^date(?::(?<format>.*))?$/
-        # TODO: grafana does not seem to allow multiselection of variables with date format - raise an error if this happens anyway
-        get_date_formatted(value, Regexp.last_match(1))
+        if multi? && value.is_a?(Array)
+          raise GrafanaError, "Date format cannot be specified for a variable containing an array of values"
+        end
+        Variable.format_as_date(value, Regexp.last_match(1))
 
       when ''
         # default
@@ -168,8 +174,9 @@ module Grafana
       end
     end
 
-    # @return [Boolean] true, if the value can contain multiple selections, i.e. can contain an Array
+    # @return [Boolean] true, if the value can contain multiple selections, i.e. can contain an Array or does contain all
     def multi?
+      return true if @raw_value == '$__all'
       return @config['multi'] unless @config['multi'].nil?
 
       @raw_value.is_a? Array
@@ -187,12 +194,13 @@ module Grafana
       @text = new_text
     end
 
-    private
-
-    # Realize time formatting according
+    # Applies the date format according
     # {https://grafana.com/docs/grafana/latest/variables/variable-types/global-variables/#__from-and-__to}
-    # and {https://momentjs.com/docs/#/displaying/}.
-    def get_date_formatted(value, format)
+    # and {https://momentjs.com/docs/#/displaying/} to a given value.
+    # @param value [String] time as milliseconds to be formatted
+    # @param format [String] format string in which the time value shall be returned
+    # @return [String] time converted to the specified time format
+    def self.format_as_date(value, format)
       return (Float(value) / 1000).to_i.to_s if format == 'seconds'
       return Time.at((Float(value) / 1000).to_i).utc.iso8601(3) if !format || (format == 'iso')
 
@@ -203,13 +211,12 @@ module Grafana
         tmp = work_string.scan(/^(?:M{1,4}|D{1,4}|d{1,4}|e|E|w{1,2}|W{1,2}|Y{4}|Y{2}|A|a|H{1,2}|
                                     h{1,2}|k{1,2}|m{1,2}|s{1,2}|S+|X)/x)
 
-        # TODO: add test for sub! and switch to non-modifying frozen string action
         if tmp.empty?
           matches << work_string[0]
-          work_string.sub!(/^#{work_string[0]}/, '')
+          work_string = work_string.sub(/^#{work_string[0]}/, '')
         else
           matches << tmp[0]
-          work_string.sub!(/^#{tmp[0]}/, '')
+          work_string = work_string.sub(/^#{tmp[0]}/, '')
         end
       end
 
@@ -221,5 +228,21 @@ module Grafana
 
       Time.at((Float(value) / 1000).to_i).strftime(format_string)
     end
+
+    private
+
+    def init_values
+      case @config['type']
+      when 'constant'
+        self.raw_value = @config['query']
+
+      else
+        if !@config['current'].nil?
+          self.raw_value = @config['current']['value']
+        else
+          raise GrafanaError.new("Grafana variable with type '#{@config['type']}' and name '#{@config['name']}' could not be handled properly. Please raise a ticket.")
+        end
+      end
+    end
   end
 end

data/lib/grafana/webrequest.rb

@@ -50,6 +50,7 @@ module Grafana
       @logger.debug("Requesting #{uri} with '#{@options[:body]}' and timeout '#{timeout}'")
       response = @http.request(request)
       @logger.debug("Received response #{response}")
+      @logger.debug("HTTP response body: #{response.body}") unless response.code =~ /^2.*/
 
       response
     end