ruby-grafana-reporter 0.1.6 → 0.3.0

data/lib/grafana/abstract_sql_query.rb

@@ -1,42 +1,51 @@
-module Grafana
-  # @abstract
-  #
-  # Used as a superclass for all queries, which execute SQL queries against {Grafana}.
-  #
-  # @see AbstractQuery
-  class AbstractSqlQuery < AbstractQuery
-    attr_reader :sql, :datasource_id
-
-    # @param raw_sql [String] raw sql statement, as it can be sent to a SQL database
-    # @param datasource_id [Integer] ID of the datasource against which the query is run
-    def initialize(raw_sql, datasource_id)
-      super()
-      @sql = raw_sql
-      @datasource_id = datasource_id
-    end
-
-    # @return [String] relative URL, where the request has to be sent to.
-    def url
-      '/api/tsdb/query'
-    end
-
-    # @return [Hash] request, which executes the SQL statement against the specified datasource
-    def request
-      { body: { from: @from, to: @to, queries: [rawSql: @sql, datasourceId: @datasource_id.to_i, format: 'table'] }.to_json, request: Net::HTTP::Post }
-    end
-
-    # Replaces all variables in the SQL statement.
-    def pre_process(grafana)
-      raise MissingSqlQueryError if @sql.nil?
-      unless grafana.datasource_id_exists?(@datasource_id.to_i)
-        raise DatasourceDoesNotExistError.new('id', @datasource_id)
-      end
-
-      @sql = replace_variables(@sql, grafana_variables)
-      # remove comments in query
-      @sql.gsub!(/--[^\r\n]*(?:[\r\n]+|$)/, ' ')
-      @sql.gsub!(/\r\n/, ' ')
-      @sql.gsub!(/\n/, ' ')
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Grafana
+  # @abstract
+  #
+  # Used as a superclass for all queries, which execute SQL queries against {Grafana}.
+  #
+  # @see AbstractQuery
+  class AbstractSqlQuery < AbstractQuery
+    attr_reader :sql, :datasource_id
+
+    # @param raw_sql [String] raw sql statement, as it can be sent to a SQL database
+    # @param datasource_id [Integer] ID of the datasource against which the query is run
+    def initialize(raw_sql, datasource_id)
+      super()
+      @sql = raw_sql
+      @datasource_id = datasource_id
+    end
+
+    # @return [String] relative URL, where the request has to be sent to.
+    def url
+      '/api/tsdb/query'
+    end
+
+    # @return [Hash] request, which executes the SQL statement against the specified datasource
+    def request
+      {
+        body: {
+          from: @from,
+          to: @to,
+          queries: [rawSql: @sql, datasourceId: @datasource_id.to_i, format: 'table']
+        }.to_json,
+        request: Net::HTTP::Post
+      }
+    end
+
+    # Replaces all variables in the SQL statement.
+    def pre_process(grafana)
+      raise MissingSqlQueryError if @sql.nil?
+      unless grafana.datasource_id_exists?(@datasource_id.to_i)
+        raise DatasourceDoesNotExistError.new('id', @datasource_id)
+      end
+
+      @sql = replace_variables(@sql, grafana_variables)
+      # remove comments in query
+      @sql.gsub!(/--[^\r\n]*(?:[\r\n]+|$)/, ' ')
+      @sql.gsub!(/\r\n/, ' ')
+      @sql.gsub!(/\n/, ' ')
+    end
+  end
+end

data/lib/grafana/dashboard.rb

@@ -1,66 +1,77 @@
-module Grafana
-  # Representation of one specific dashboard in a {Grafana} instance.
-  class Dashboard
-    # @return [Grafana] parent {Grafana} object
-    attr_reader :grafana
-    attr_reader :panels, :variables
-
-    # @param model [Hash] converted JSON Hash of the grafana dashboard
-    # @param grafana [Grafana] parent {Grafana} object
-    def initialize(model, grafana)
-      @grafana = grafana
-      @model = model
-
-      # read panels
-      @panels = []
-      if @model.key?('panels')
-        @model['panels'].each do |panel|
-          if panel.key?('panels')
-            panel['panels'].each do |subpanel|
-              @panels << Panel.new(subpanel, self)
-            end
-          else
-            @panels << Panel.new(panel, self)
-          end
-        end
-      end
-
-      # store variables in array as objects of type Variable
-      @variables = []
-      return unless @model.key?('templating')
-
-      list = @model['templating']['list']
-      return unless list.is_a? Array
-
-      list.each do |item|
-        @variables << Variable.new(item)
-      end
-    end
-
-    # @return [String] +from+ time configured in the dashboard.
-    def from_time
-      return @model['time']['from'] if @model['time']
-
-      nil
-    end
-
-    # @return [String] +to+ time configured in the dashboard.
-    def to_time
-      @model['time']['to'] if @model['time']
-      nil
-    end
-
-    # @return [String] dashboard UID
-    def id
-      @model['uid']
-    end
-
-    # @return [Panel] panel for the specified ID
-    def panel(id)
-      panels = @panels.select { |item| item.field('id') == id.to_i }
-      raise PanelDoesNotExistError.new(id, self) if panels.empty?
-
-      panels.first
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Grafana
+  # Representation of one specific dashboard in a {Grafana} instance.
+  class Dashboard
+    # @return [Grafana] parent {Grafana} object
+    attr_reader :grafana
+    attr_reader :panels, :variables
+
+    # @param model [Hash] converted JSON Hash of the grafana dashboard
+    # @param grafana [Grafana] parent {Grafana} object
+    def initialize(model, grafana)
+      @grafana = grafana
+      @model = model
+
+      init_panels
+      init_variables
+    end
+
+    # @return [String] +from+ time configured in the dashboard.
+    def from_time
+      return @model['time']['from'] if @model['time']
+
+      nil
+    end
+
+    # @return [String] +to+ time configured in the dashboard.
+    def to_time
+      @model['time']['to'] if @model['time']
+      nil
+    end
+
+    # @return [String] dashboard UID
+    def id
+      @model['uid']
+    end
+
+    # @return [Panel] panel for the specified ID
+    def panel(id)
+      panels = @panels.select { |item| item.field('id') == id.to_i }
+      raise PanelDoesNotExistError.new(id, self) if panels.empty?
+
+      panels.first
+    end
+
+    private
+
+    # store variables in array as objects of type Variable
+    def init_variables
+      @variables = []
+      return unless @model.key?('templating')
+
+      list = @model['templating']['list']
+      return unless list.is_a? Array
+
+      list.each do |item|
+        @variables << Variable.new(item)
+      end
+    end
+
+    # read panels
+    def init_panels
+      @panels = []
+      return unless @model.key?('panels')
+
+      @model['panels'].each do |panel|
+        if panel.key?('panels')
+          panel['panels'].each do |subpanel|
+            @panels << Panel.new(subpanel, self)
+          end
+        else
+          @panels << Panel.new(panel, self)
+        end
+      end
+    end
+  end
+end

data/lib/grafana/errors.rb

@@ -1,61 +1,66 @@
-module Grafana
-  # A top level alarm for all other errors in current module.
-  class GrafanaError < StandardError
-    def initialize(message)
-      super("GrafanaError: #{message} (#{self.class})")
-    end
-  end
-
-  # Raised if a given dashboard does not exist in a specific {Grafana} instance.
-  class DashboardDoesNotExistError < GrafanaError
-    # @param dashboard_uid [String] dashboard uid, which could not be found
-    def initialize(dashboard_uid)
-      super("The specified dashboard '#{dashboard_uid}' does not exist.")
-    end
-  end
-
-  # Raised if a given panel does not exist on a specific {Dashboard} in the current {Grafana} instance.
-  class PanelDoesNotExistError < GrafanaError
-    # @param panel_id [String] panel id, which could not be found on the dashboard
-    # @param dashboard [Dashboard] dashboard object on which the panel could not be found
-    def initialize(panel_id, dashboard)
-      super("The specified panel id '#{panel_id}' does not exist on the dashboard '#{dashboard.id}'.")
-    end
-  end
-
-  # Raised if a given query letter does not exist on a specific {Panel}.
-  class QueryLetterDoesNotExistError < GrafanaError
-    # @param query_letter [String] query letter name, which could not be found on the panel
-    # @param panel [Panel] panel object on which the query could not be found
-    def initialize(query_letter, panel)
-      super("The specified query '#{query_letter}' does not exist in the panel '#{panel.id}' in dashboard '#{panel.dashboard}'.")
-    end
-  end
-
-  # 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 datasource_identifier [String] identifier of the datasource, which could not be found, e.g. the specifiy id or name
-    def initialize(field, datasource_identifier)
-      super("Datasource with #{field} '#{datasource_identifier}' does not exist.")
-    end
-  end
-
-  # Raised if a {Panel} could not be rendered as an image.
-  #
-  # Most likely this happens, because the image renderer is not configures properly in grafana,
-  # or the panel rendering ran into a timeout.
-  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 rendered to an image.")
-    end
-  end
-
-  # Raised if no SQL query is specified in a {AbstractSqlQuery} object.
-  class MissingSqlQueryError < GrafanaError
-    def initialize
-      super('No SQL statement has been specified.')
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Grafana
+  # A top level alarm for all other errors in current module.
+  class GrafanaError < StandardError
+    def initialize(message)
+      super("GrafanaError: #{message} (#{self.class})")
+    end
+  end
+
+  # Raised if a given dashboard does not exist in a specific {Grafana} instance.
+  class DashboardDoesNotExistError < GrafanaError
+    # @param dashboard_uid [String] dashboard uid, which could not be found
+    def initialize(dashboard_uid)
+      super("The specified dashboard '#{dashboard_uid}' does not exist.")
+    end
+  end
+
+  # Raised if a given panel does not exist on a specific {Dashboard} in the current {Grafana} instance.
+  class PanelDoesNotExistError < GrafanaError
+    # @param panel_id [String] panel id, which could not be found on the dashboard
+    # @param dashboard [Dashboard] dashboard object on which the panel could not be found
+    def initialize(panel_id, dashboard)
+      super("The specified panel id '#{panel_id}' does not exist on the dashboard '#{dashboard.id}'.")
+    end
+  end
+
+  # Raised if a given query letter does not exist on a specific {Panel}.
+  class QueryLetterDoesNotExistError < GrafanaError
+    # @param query_letter [String] query letter name, which could not be found on the panel
+    # @param panel [Panel] panel object on which the query could not be found
+    def initialize(query_letter, panel)
+      super("The specified query '#{query_letter}' does not exist in the panel '#{panel.id}' "\
+        "in dashboard '#{panel.dashboard}'.")
+    end
+  end
+
+  # 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 datasource_identifier [String] identifier of the datasource, which could not be found,
+    #   e.g. the specifiy id or name
+    def initialize(field, datasource_identifier)
+      super("Datasource with #{field} '#{datasource_identifier}' does not exist.")
+    end
+  end
+
+  # Raised if a {Panel} could not be rendered as an image.
+  #
+  # Most likely this happens, because the image renderer is not configures properly in grafana,
+  # or the panel rendering ran into a timeout.
+  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 "\
+        'rendered to an image.')
+    end
+  end
+
+  # Raised if no SQL query is specified in a {AbstractSqlQuery} object.
+  class MissingSqlQueryError < GrafanaError
+    def initialize
+      super('No SQL statement has been specified.')
+    end
+  end
+end

data/lib/grafana/grafana.rb

@@ -1,131 +1,133 @@
-# Contains all objects for creating structured objects for interfacing grafana.
-#
-# The intention is, that these represent the business logic contained within grafana in an appropriate object model for the reporter to work with.
-#
-# For details, see also {https://grafana.com/docs/grafana/latest/http_api Grafana API}.
-module Grafana
-  # Main class for handling the interaction with one specific Grafana instance.
-  class Grafana
-    # @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.
-    def initialize(base_uri, key = nil, opts = {})
-      @base_uri = base_uri
-      @key = key
-      @dashboards = {}
-      @logger = opts[:logger] || ::Logger.new(nil)
-      @datasources = opts[:datasources]
-    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,
-    # or even fails on connecting to grafana.
-    #
-    # @return [String] +Admin+, +NON-Admin+ or +Failed+ is returned, depending on the test results
-    def test_connection
-      res = execute_http_request('/api/datasources')
-      if res.is_a?(Net::HTTPOK)
-        # we have admin rights
-        @logger.info('Reporter is running with Admin privileges on grafana.')
-        return 'Admin'
-      else
-        # check if we have lower rights
-        res = execute_http_request('/api/dashboards/home')
-        if res.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')
-          return 'NON-Admin'
-        end
-      end
-
-      'Failed'
-    end
-
-    # Returns the ID of a 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
-
-      id
-    end
-
-    # Returns if the given datasource ID exists for the grafana instance.
-    #
-    # @return [Boolean] true if exists, false otherwise
-    def datasource_id_exists?(datasource_id)
-      datasources.value?(datasource_id)
-    end
-
-    # @param dashboard_uid [String] UID of the searched {Dashboard}
-    # @return [Dashboard] dashboard object, if it has been found
-    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?
-
-      # cache dashboard for reuse
-      @dashboards[dashboard_uid] = Dashboard.new(model, self)
-
-      @dashboards[dashboard_uid]
-    end
-
-    # Runs a specific HTTP request against the current grafana instance.
-    #
-    # 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}'")
-      resp = http.request(request)
-      resp
-    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
-      end
-      @datasources
-    end
-  end
-end
+# frozen_string_literal: true
+
+# Contains all objects for creating structured objects for interfacing grafana.
+#
+# The intention is, that these represent the business logic contained within grafana
+# in an appropriate object model for the reporter to work with.
+#
+# For details, see also {https://grafana.com/docs/grafana/latest/http_api Grafana API}.
+module Grafana
+  # Main class for handling the interaction with one specific Grafana instance.
+  class Grafana
+    # @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 +:ssl_cert+.
+    def initialize(base_uri, key = nil, opts = {})
+      @base_uri = base_uri
+      @key = key
+      @dashboards = {}
+      @ssl_cert = opts[:ssl_cert]
+      @logger = opts[:logger] || ::Logger.new(nil)
+
+      initialize_datasources unless @base_uri.empty?
+    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,
+    # or even fails on connecting to 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)
+        # we have admin rights
+        @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)
+
+      @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.
+    #
+    # @return [Integer] ID for the specified datasource name
+    def datasource_id(datasource_name)
+      datasource_name ||= 'default'
+      return @datasources[datasource_name] if @datasources[datasource_name]
+
+      raise DatasourceDoesNotExistError.new('name', datasource_name)
+    end
+
+    # Returns if the given datasource ID exists for the grafana instance.
+    #
+    # @return [Boolean] true if exists, false otherwise
+    def datasource_id_exists?(datasource_id)
+      @datasources.value?(datasource_id)
+    end
+
+    # @param dashboard_uid [String] UID of the searched {Dashboard}
+    # @return [Dashboard] dashboard object, if it has been found
+    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?
+
+      # cache dashboard for reuse
+      @dashboards[dashboard_uid] = Dashboard.new(model, self)
+
+      @dashboards[dashboard_uid]
+    end
+
+    # Runs a specific HTTP request against the current grafana instance.
+    #
+    # 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
+        if @ssl_cert && !File.exist?(@ssl_cert)
+          @logger.warn('SSL certificate file does not exist.')
+        elsif @ssl_cert
+          http.cert_store = OpenSSL::X509::Store.new
+          http.cert_store.set_default_paths
+          http.cert_store.add_file(@ssl_cert)
+        end
+      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)
+    end
+
+    private
+
+    def initialize_datasources
+      @datasources = {}
+
+      settings = execute_http_request('/api/frontend/settings')
+      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] = ds_value['id'].to_i
+      end
+      @datasources['default'] = @datasources[json['defaultDatasource']]
+    end
+  end
+end