ruby-grafana-reporter 0.4.1 → 0.4.5

data/lib/VERSION.rb

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

data/lib/grafana/abstract_datasource.rb

@@ -8,19 +8,18 @@ module Grafana
 
     @@subclasses = []
 
-    # Registers the subclass as datasource, which is asked by {#accepts?}, if it can handle a datasource
-    # model.
+    # Registers the subclass as datasource.
     # @param subclass [Class] class inheriting from this abstract class
     def self.inherited(subclass)
       @@subclasses << subclass
     end
 
     # Overwrite this method, to specify if the current datasource implementation handles the given model.
-    # This method is called by {#build_instance} to determine, if the current datasource implementation
+    # This method is called by {build_instance} to determine, if the current datasource implementation
     # can handle the given grafana model. By default this method returns false.
     # @param model [Hash] grafana specification of the datasource to check
     # @return [Boolean] True if fits, false otherwise
-    def self.handles?(_model)
+    def self.handles?(model)
       false
     end
 
@@ -43,12 +42,12 @@ module Grafana
       @model = model
     end
 
-    # @return [String] category of the datasource, e.g. `tsdb` or `sql`
+    # @return [String] category of the datasource, e.g. +tsdb+ or +sql+
     def category
       @model['meta']['category']
     end
 
-    # @return [String] type of the datasource, e.g. `mysql`
+    # @return [String] type of the datasource, e.g. +mysql+
     def type
       @model['type'] || @model['meta']['id']
     end
@@ -78,12 +77,12 @@ module Grafana
     #   }
     #
     # @param query_description [Hash] query description, which will requested:
-    # @option [String] :from +from+ timestamp
-    # @option [String] :to +to+ timestamp
-    # @option [Integer] :timeout expected timeout for the request
-    # @option [WebRequest] :prepared_request prepared web request for relevant {Grafana} instance, if this is needed by datasource
-    # @option [String] :raw_query raw query, which shall be executed. May include variables, which will be replaced before execution
-    # @option [Hash<Variable>] :variables hash of variables, which can potentially be replaced in the given +:raw_query+
+    # @option query_description [String] :from +from+ timestamp
+    # @option query_description [String] :to +to+ timestamp
+    # @option query_description [Integer] :timeout expected timeout for the request
+    # @option query_description [WebRequest] :prepared_request prepared web request for relevant {Grafana} instance, if this is needed by datasource
+    # @option query_description [String] :raw_query raw query, which shall be executed. May include variables, which will be replaced before execution
+    # @option query_description [Hash<Variable>] :variables hash of variables, which can potentially be replaced in the given +:raw_query+
     # @return [Hash] sql result formatted as stated above
     def request(query_description)
       raise NotImplementedError
@@ -101,6 +100,14 @@ module Grafana
       raise NotImplementedError
     end
 
+    # @abstract
+    #
+    # Overwrite in subclass, to specify the default variable format during replacement of variables.
+    # @return [String] default {Variable#value_formatted} format
+    def default_variable_format
+      raise NotImplementedError
+    end
+
     private
 
     # Replaces the grafana variables in the given string with their replacement value.
@@ -119,12 +126,18 @@ module Grafana
       while repeat && (repeat_count < 3)
         repeat = false
         repeat_count += 1
-        variables.each do |var_name, obj|
+
+        variables.each do |name, variable|
           # only set ticks if value is string
-          variable = var_name.gsub(/^var-/, '')
-          res = res.gsub(/(?:\$\{#{variable}(?::(?<format>\w+))?\}|\$#{variable})/) do
-            # TODO: respect datasource requirements for formatting here
-            obj.value_formatted($LAST_MATCH_INFO ? $LAST_MATCH_INFO[:format] : nil)
+          var_name = name.gsub(/^var-/, '')
+          next unless var_name =~ /^\w+$/
+
+          res = res.gsub(/(?:\$\{#{var_name}(?::(?<format>\w+))?\}|\$#{var_name}(?!\w))/) do
+            format = default_variable_format
+            if $LAST_MATCH_INFO
+              format = $LAST_MATCH_INFO[:format] if $LAST_MATCH_INFO[:format]
+            end
+            variable.value_formatted(format)
           end
         end
         repeat = true if res.include?('$')

data/lib/grafana/errors.rb

@@ -37,9 +37,9 @@ module Grafana
 
   # Raised if a given datasource does not exist in a specific {Grafana} instance.
   class DatasourceDoesNotExistError < GrafanaError
-    # @param field [String] specifies, how the datasource has been searched, e.g. 'id' or 'name'
+    # @param field [String] specifies, how the datasource has been searched, e.g. +id+ or +name+
     # @param datasource_identifier [String] identifier of the datasource, which could not be found,
-    #   e.g. the specifiy id or name
+    #   e.g. the specified id or name
     def initialize(field, datasource_identifier)
       super("Datasource with #{field} '#{datasource_identifier}' does not exist.")
     end
@@ -49,10 +49,10 @@ module Grafana
   #
   # Most likely this happens, because the image renderer is not configures properly in grafana,
   # or the panel rendering ran into a timeout.
+  # @param panel [Panel] panel object, which could not be rendered
   class ImageCouldNotBeRenderedError < GrafanaError
-    # @param panel [Panel] panel object, which could not be rendered
     def initialize(panel)
-      super("The specified panel '#{panel.id}' from dashboard '#{panel.dashboard.id} could not be "\
+      super("The specified panel '#{panel.id}' from dashboard '#{panel.dashboard.id}' could not be "\
         'rendered to an image.')
     end
   end

data/lib/grafana/grafana.rb

@@ -50,6 +50,8 @@ module Grafana
     # @return [Datasource] Datasource for the specified datasource name
     def datasource_by_name(datasource_name)
       datasource_name = 'default' if datasource_name.to_s.empty?
+      # TODO: PRIO add support for grafana builtin datasource types
+      return UnsupportedDatasource.new(nil) if datasource_name.to_s =~ /-- (?:Mixed|Dashboard|Grafana) --/
       raise DatasourceDoesNotExistError.new('name', datasource_name) unless @datasources[datasource_name]
 
       @datasources[datasource_name]

data/lib/grafana/grafana_property_datasource.rb

@@ -16,10 +16,22 @@ module Grafana
       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

@@ -36,15 +36,37 @@ module Grafana
       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)
-      # TODO: support multiple metrics as return types
-      {
-        header: %w[value time],
-        content: JSON.parse(response_body).first['datapoints']
-      }
+      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/influxdb_datasource.rb

@@ -0,0 +1,156 @@
+# 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?
+
+      # replace variables
+      query = replace_variables(query_description[:raw_query], query_description[:variables])
+
+      # Unfortunately the grafana internal variables are not replaced in the grafana backend, but in the
+      # frontend, i.e. we have to replace them here manually
+      # replace $timeFilter variable
+      query = query.gsub(/\$timeFilter(?=\W|$)/, "time >= #{query_description[:from]}ms and time <= #{query_description[:to]}ms")
+
+      # 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}")
+
+      url = "/api/datasources/proxy/#{id}/query?db=#{@model['database']}&q=#{ERB::Util.url_encode(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']
+
+      # build composed queries
+      build_select(panel_query_target['select']) + build_from(panel_query_target) + build_where(panel_query_target['tags']) + build_group_by(panel_query_target['groupBy'])
+    end
+
+    # @see AbstractDatasource#default_variable_format
+    def default_variable_format
+      'regex'
+    end
+
+    private
+
+    def build_group_by(stmt)
+      groups = []
+      fill = ""
+
+      stmt.each do |group|
+        case group['type']
+        when 'tag'
+          groups << "\"#{group['params'].first}\""
+
+        when 'fill'
+          fill = " fill(#{group['params'].first})"
+
+        else
+          groups << "#{group['type']}(#{group['params'].join(', ')})"
+
+        end
+      end
+
+      " GROUP BY #{groups.join(', ')}#{fill}"
+    end
+
+    def build_where(stmt)
+      custom_where = []
+
+      stmt.each do |where|
+        value = where['operator'] =~ /^[=!]~$/ ? where['value'] : "'#{where['value']}'"
+        custom_where << "\"#{where['key']}\" #{where['operator']} #{value}"
+      end
+
+      " WHERE #{"(#{custom_where.join(' AND ')}) AND " unless custom_where.empty?}$timeFilter"
+    end
+
+    def build_from(stmt)
+      " FROM \"#{"stmt['policy']." unless stmt['policy'] == 'default'}#{stmt['measurement']}\""
+    end
+
+    def build_select(stmt)
+      res = "SELECT"
+      parts = []
+
+      stmt.each do |value|
+        part = ""
+
+        value.each do |item|
+          case item['type']
+          when 'field'
+            # frame field parameter as string
+            part = "\"#{item['params'].first}\""
+
+          when 'alias'
+            # append AS with parameter as string
+            part = "#{part} AS \"#{item['params'].first}\""
+
+
+          when 'math'
+            # append parameter as raw value for calculation
+            part = "#{part} #{item['params'].first}"
+
+
+          else
+            # frame current part by brackets and call by item function including parameters
+            part = "#{item['type']}(#{part}#{", #{item['params'].join(', ')}" unless item['params'].empty?})"
+          end
+        end
+
+        parts << part
+      end
+
+      "#{res} #{parts.join(', ')}"
+    end
+
+    # @see AbstractDatasource#preformat_response
+    def preformat_response(response_body)
+      # TODO: how to handle multiple query results?
+      json = JSON.parse(response_body)['results'].first['series']
+      return {} if json.nil?
+
+      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

@@ -18,7 +18,7 @@ module Grafana
     def field(field)
       return @model[field] if @model.key?(field)
 
-      ''
+      nil
     end
 
     # @return [String] panel ID

data/lib/grafana/prometheus_datasource.rb

@@ -14,7 +14,11 @@ module Grafana
     def request(query_description)
       raise MissingSqlQueryError if query_description[:raw_query].nil?
 
-      url = "/api/datasources/proxy/#{id}/api/v1/query_range?"\
+      # TODO: properly allow endpoint to be set - also check raw_query method
+      end_point = @endpoint ? @endpoint : "query_range"
+
+      # 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])}"
 
@@ -28,18 +32,45 @@ 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']
     end
 
+    # @see AbstractDatasource#default_variable_format
+    def default_variable_format
+        'regex'
+    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']
-      }
+      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
+      # 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
+
+      # 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

@@ -19,7 +19,7 @@ module Grafana
         body: {
           from: query_description[:from],
           to: query_description[:to],
-          queries: [rawSql: prepare_sql(sql), datasourceId: id, format: 'table']
+          queries: [rawSql: sql, datasourceId: id, format: 'table']
         }.to_json,
         request: Net::HTTP::Post
       }
@@ -32,11 +32,18 @@ module Grafana
       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)
@@ -45,12 +52,12 @@ module Grafana
 
       JSON.parse(response_body)['results'].each_value do |query_result|
         if query_result.key?('error')
-          results[:header] = results[:header] << ['SQL 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[:header] = results[:header] + table['columns'].map { |header| header['text'] }
             results[:content] = table['rows']
           end
 
@@ -59,13 +66,5 @@ module Grafana
 
       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