ruby-grafana-reporter 0.4.1 → 0.4.5

data/lib/grafana_reporter/asciidoctor/panel_image_block_macro.rb

@@ -46,13 +46,14 @@ module GrafanaReporter
                              " panel: #{target})")
 
         begin
-          query = PanelImageQuery.new(@report.grafana(instance).dashboard(dashboard).panel(target))
-          assign_dashboard_defaults(query, @report.grafana(instance).dashboard(dashboard))
-          assign_doc_and_item_variables(query, parent.document.attributes, attrs)
-          @report.logger.debug("from: #{query.from}, to: #{query.to}")
+          query = PanelImageQuery.new(@report.grafana(instance).dashboard(dashboard).panel(target),
+                                      variables: build_attribute_hash(parent.document.attributes, attrs))
 
           image = query.execute
           image_path = @report.save_image_file(image)
+        rescue Grafana::GrafanaError => e
+          @report.logger.error(e.message)
+          return create_paragraph(parent, e.message, attrs)
         rescue GrafanaReporterError => e
           @report.logger.error(e.message)
           return create_paragraph(parent, e.message, attrs)

data/lib/grafana_reporter/asciidoctor/panel_image_inline_macro.rb

@@ -46,15 +46,16 @@ module GrafanaReporter
                              " panel: #{target})")
 
         begin
-          query = PanelImageQuery.new(@report.grafana(instance).dashboard(dashboard).panel(target))
           # set alt text to a default, because otherwise asciidoctor fails
           attrs['alt'] = '' unless attrs['alt']
-          assign_dashboard_defaults(query, @report.grafana(instance).dashboard(dashboard))
-          assign_doc_and_item_variables(query, parent.document.attributes, attrs)
-          @report.logger.debug("from: #{query.from}, to: #{query.to}")
+          query = PanelImageQuery.new(@report.grafana(instance).dashboard(dashboard).panel(target),
+                                      variables: build_attribute_hash(parent.document.attributes, attrs))
 
           image = query.execute
           image_path = @report.save_image_file(image)
+        rescue Grafana::GrafanaError => e
+          @report.logger.error(e.message)
+          return create_inline(parent, :quoted, e.message)
         rescue GrafanaReporterError => e
           @report.logger.error(e.message)
           return create_inline(parent, :quoted, e.message)

data/lib/grafana_reporter/asciidoctor/panel_property_inline_macro.rb

@@ -38,13 +38,14 @@ module GrafanaReporter
                              " panel: #{target}, property: #{attrs[:field]})")
 
         begin
-          query = PanelPropertyQuery.new(@report.grafana(instance).dashboard(dashboard).panel(target))
+          query = PanelPropertyQuery.new(@report.grafana(instance).dashboard(dashboard).panel(target),
+                                         variables: build_attribute_hash(parent.document.attributes, attrs))
           query.raw_query = { property_name: attrs[:field] }
-          assign_dashboard_defaults(query, @report.grafana(instance).dashboard(dashboard))
-          assign_doc_and_item_variables(query, parent.document.attributes, attrs)
-          @report.logger.debug("from: #{query.from}, to: #{query.to}")
 
           description = query.execute
+        rescue Grafana::GrafanaError => e
+          @report.logger.error(e.message)
+          return create_inline(parent, :quoted, e.message)
         rescue GrafanaReporterError => e
           @report.logger.error(e.message)
           return create_inline(parent, :quoted, e.message)

data/lib/grafana_reporter/asciidoctor/panel_query_table_include_processor.rb

@@ -51,7 +51,6 @@ module GrafanaReporter
 
         @report.next_step
         panel_id = target.split(':')[1]
-        # TODO: check if instance and dashboard shouldn't be set in assign_doc_and_item_variables method
         instance = attrs['instance'] || doc.attr('grafana_default_instance') || 'default'
         dashboard = attrs['dashboard'] || doc.attr('grafana_default_dashboard')
         attrs['result_type'] = 'panel_table'
@@ -60,12 +59,13 @@ module GrafanaReporter
 
         begin
           panel = @report.grafana(instance).dashboard(dashboard).panel(panel_id)
-          query = QueryValueQuery.new(panel)
-          assign_dashboard_defaults(query, panel.dashboard)
-          assign_doc_and_item_variables(query, doc.attributes, attrs)
-          @report.logger.debug("from: #{query.from}, to: #{query.to}")
+          vars = { 'table_formatter' => 'adoc_plain' }.merge(build_attribute_hash(doc.attributes, attrs))
+          query = QueryValueQuery.new(panel, variables: vars)
 
-          reader.unshift_lines query.execute
+          reader.unshift_lines query.execute.split("\n")
+        rescue Grafana::GrafanaError => e
+          @report.logger.error(e.message)
+          reader.unshift_line "|#{e.message}"
         rescue GrafanaReporterError => e
           @report.logger.error(e.message)
           reader.unshift_line "|#{e.message}"

data/lib/grafana_reporter/asciidoctor/panel_query_value_inline_macro.rb

@@ -56,12 +56,12 @@ module GrafanaReporter
 
         begin
           panel = @report.grafana(instance).dashboard(dashboard).panel(target)
-          query = QueryValueQuery.new(panel)
-          assign_dashboard_defaults(query, panel.dashboard)
-          assign_doc_and_item_variables(query, parent.document.attributes, attrs)
-          @report.logger.debug("from: #{query.from}, to: #{query.to}")
+          query = QueryValueQuery.new(panel, variables: build_attribute_hash(parent.document.attributes, attrs))
 
           create_inline(parent, :quoted, query.execute)
+        rescue Grafana::GrafanaError => e
+          @report.logger.error(e.message)
+          create_inline(parent, :quoted, e.message)
         rescue GrafanaReporterError => e
           @report.logger.error(e.message)
           create_inline(parent, :quoted, e.message)

data/lib/grafana_reporter/asciidoctor/processor_mixin.rb

@@ -19,45 +19,31 @@ module GrafanaReporter
         raise NotImplementedError
       end
 
-      # Sets default configurations from the given {Grafana::Dashboard} and store them as settings in the
-      # {AbstractQuery}.
-      #
-      # Following data is extracted:
-      # - +from+, by {Grafana::Dashboard#from_time}
-      # - +to+, by {Grafana::Dashboard#to_time}
-      # - and all variables as {Grafana::Variable}, prefixed with +var-+, as grafana also does it
-      # @param query [AbstractQuery] query object, for which the defaults are set
-      # @param dashboard [Grafana::Dashboard] dashboard from which the defaults are captured
-      # TODO: assign_dashboard_defaults is a common method for all report classes - move it to a public place
-      def assign_dashboard_defaults(query, dashboard)
-        query.from = dashboard.from_time
-        query.to = dashboard.to_time
-        dashboard.variables.each { |item| query.assign_variable("var-#{item.name}", item) }
-      end
-
-      # Merges the given hashes to the given query object. It respects the priorities of the hashes and the
-      # object and allows only valid variables to be passed.
-      # @param query [AbstractQuery] query object, for which the defaults are set
+      # Merges the given hashes to a common attribute Hash. It respects the priorities of the hashes and the
+      # object and allows only valid variables to be used.
       # @param document_hash [Hash] variables from report template level
       # @param item_hash [Hash] variables from item configuration level, i.e. specific call, which may override document
-      # @return [void]
-      def assign_doc_and_item_variables(query, document_hash, item_hash)
-        sel_doc_items = document_hash.select do |k, _v|
-          k =~ /^var-/ || k =~ /grafana_default_(?:from|to)_timezone/
-        end
-        sel_doc_items.each { |k, v| query.assign_variable(k, ::Grafana::Variable.new(v)) }
-        query.assign_variable('grafana_report_timestamp', ::Grafana::Variable.new(document_hash['localdatetime']))
+      # @return [Hash] containing accepted variable names including values
+      def build_attribute_hash(document_hash, item_hash)
+        result = {}
+
+        result['grafana_report_timestamp'] = document_hash['localdatetime']
+        result.merge!(document_hash.select do |k, _v|
+          k =~ /^var-/ ||
+          k =~ /^(?:from|to)$/ ||
+          k =~ /^grafana_default_(?:from_timezone|to_timezone|timeout)$/
+        end)
 
-        sel_items = item_hash.select do |k, _v|
-          # TODO: specify accepted options in each class or check if simply all can be allowed with prefix +var-+
-          k =~ /^var-/ || k =~ /^render-/ || k =~ /filter_columns|format|replace_values_.*|transpose|column_divider|
-                                                   row_divider|from_timezone|to_timezone|result_type|query/x
-        end
-        sel_items.each { |k, v| query.assign_variable(k, ::Grafana::Variable.new(v)) }
+        result.merge!(item_hash.select do |k, _v|
+          # TODO: specify accepted options for each processor class individually
+          k =~ /^(?:var-|render-)/ ||
+          k =~ /^(?:timeout|from|to)$/ ||
+          k =~ /filter_columns|format|replace_values_.*|transpose|from_timezone|
+               to_timezone|result_type|query|table_formatter|include_headline|
+               column_divider|row_divider/x
+        end)
 
-        query.timeout = item_hash['timeout'] || document_hash['grafana-default-timeout'] || query.timeout
-        query.from = item_hash['from'] || document_hash['from'] || query.from
-        query.to = item_hash['to'] || document_hash['to'] || query.to
+        result
       end
     end
   end

data/lib/grafana_reporter/asciidoctor/report.rb

@@ -14,9 +14,8 @@ module GrafanaReporter
 
       # Starts to create an asciidoctor report. It utilizes all extensions in the {GrafanaReporter::Asciidoctor}
       # namespace to realize the conversion.
-      # @see AbstractReport#create_report
-      def create_report(template, destination_file_or_path = nil, custom_attributes = {})
-        super
+      # @see AbstractReport#build
+      def build
         attrs = { 'convert-backend' => 'pdf' }.merge(@config.default_document_attributes.merge(@custom_attributes))
         logger.debug("Document attributes: #{attrs}")
 
@@ -42,22 +41,14 @@ module GrafanaReporter
         ::Asciidoctor.convert_file(@template, extension_registry: registry, backend: attrs['convert-backend'],
                                               to_file: path, attributes: attrs, header_footer: true)
 
-        @destination_file_or_path.close if @destination_file_or_path.is_a?(File)
-
         # store report including als images as ZIP file, if the result is not a PDF
         if attrs['convert-backend'] != 'pdf'
-          dest_path = if @destination_file_or_path.is_a?(File) || @destination_file_or_path.is_a?(Tempfile)
-                        @destination_file_or_path.path
-                      else
-                        @destination_file_or_path
-                      end
-
           # build zip file
           zip_file = Tempfile.new('gf_zip')
           buffer = Zip::OutputStream.write_buffer do |zipfile|
             # add report file
-            zipfile.put_next_entry("#{dest_path.gsub(@config.reports_folder, '')}.#{attrs['convert-backend']}")
-            zipfile.write File.read(dest_path)
+            zipfile.put_next_entry("#{path.gsub(@config.reports_folder, '')}.#{attrs['convert-backend']}")
+            zipfile.write File.read(path)
 
             # add image files
             @image_files.each do |file|
@@ -72,9 +63,9 @@ module GrafanaReporter
           # replace original file with zip file
           zip_file.rewind
           begin
-            File.write(dest_path, zip_file.read)
+            File.write(path, zip_file.read)
           rescue StandardError => e
-            logger.fatal("Could not overwrite report file '#{dest_path}' with ZIP file. (#{e.message}).")
+            logger.fatal("Could not overwrite report file '#{path}' with ZIP file. (#{e.message}).")
           end
 
           # cleanup temporary zip file
@@ -83,17 +74,6 @@ module GrafanaReporter
         end
 
         clean_image_files
-      rescue MissingTemplateError => e
-        @logger.error(e.message)
-        @error = [e.message]
-        done!
-        raise e
-      rescue StandardError => e
-        # catch all errors during execution
-        died_with_error(e)
-        raise e
-      ensure
-        done!
       end
 
       # Called to save a temporary image file. After the final generation of the
@@ -112,6 +92,16 @@ module GrafanaReporter
         path
       end
 
+      # @see AbstractReport#default_template_extension
+      def self.default_template_extension
+        'adoc'
+      end
+
+      # @see AbstractReport#default_result_extension
+      def self.default_result_extension
+        'pdf'
+      end
+
       # @see AbstractReport#demo_report_classes
       def self.demo_report_classes
         [AlertsTableIncludeProcessor, AnnotationsTableIncludeProcessor, PanelImageBlockMacro, PanelImageInlineMacro,

data/lib/grafana_reporter/asciidoctor/show_help_include_processor.rb

@@ -23,7 +23,7 @@ module GrafanaReporter
         @report.next_step
         @report.logger.debug('Processing ShowHelpIncludeProcessor')
 
-        reader.unshift_lines GrafanaReporter::Help.new.asciidoctor.split("\n")
+        reader.unshift_lines Help.new.asciidoctor.split("\n")
       end
 
       # @see ProcessorMixin#build_demo_entry

data/lib/grafana_reporter/asciidoctor/sql_table_include_processor.rb

@@ -51,13 +51,15 @@ module GrafanaReporter
 
         begin
           # catch properly if datasource could not be identified
-          query = QueryValueQuery.new(@report.grafana(instance))
+          vars = { 'table_formatter' => 'adoc_plain' }.merge(build_attribute_hash(doc.attributes, attrs))
+          query = QueryValueQuery.new(@report.grafana(instance), variables: vars)
           query.datasource = @report.grafana(instance).datasource_by_id(target.split(':')[1].to_i)
           query.raw_query = attrs['sql']
-          assign_doc_and_item_variables(query, doc.attributes, attrs)
-          @report.logger.debug("from: #{query.from}, to: #{query.to}")
 
-          reader.unshift_lines query.execute
+          reader.unshift_lines query.execute.split("\n")
+        rescue Grafana::GrafanaError => e
+          @report.logger.error(e.message)
+          reader.unshift_line "|#{e.message}"
         rescue GrafanaReporterError => e
           @report.logger.error(e.message)
           reader.unshift_line "|#{e.message}"

data/lib/grafana_reporter/asciidoctor/sql_value_inline_macro.rb

@@ -49,13 +49,15 @@ module GrafanaReporter
 
         begin
           # catch properly if datasource could not be identified
-          query = QueryValueQuery.new(@report.grafana(instance))
+          query = QueryValueQuery.new(@report.grafana(instance),
+                                      variables: build_attribute_hash(parent.document.attributes, attrs))
           query.datasource = @report.grafana(instance).datasource_by_id(target)
           query.raw_query = attrs['sql']
-          assign_doc_and_item_variables(query, parent.document.attributes, attrs)
-          @report.logger.debug("from: #{query.from}, to: #{query.to}")
 
           create_inline(parent, :quoted, query.execute)
+        rescue Grafana::GrafanaError => e
+          @report.logger.error(e.message)
+          create_inline(parent, :quoted, e.message)
         rescue GrafanaReporterError => e
           @report.logger.error(e.message)
           create_inline(parent, :quoted, e.message)

data/lib/grafana_reporter/console_configuration_wizard.rb

@@ -39,7 +39,7 @@ module GrafanaReporter
       puts 'Now everything is setup properly. Create your reports as required in the templates '\
            'folder and run the reporter either standalone with e.g. the following command:'
       puts
-      puts "   #{program_call}#{config_param} -t #{demo_report} -o demo_report_with_help.pdf"
+      puts "   #{program_call}#{config_param} -t #{demo_report} -o demo_report.#{config.report_class.default_result_extension}"
       puts
       puts 'or run it as a service using the following command:'
       puts
@@ -120,7 +120,7 @@ default-document-attributes:
       return nil unless create =~ /^(?:y|Y)$/
 
       demo_report = 'demo_report'
-      demo_report_file = "#{config.templates_folder}#{demo_report}.adoc"
+      demo_report_file = "#{config.templates_folder}#{demo_report}.#{config.report_class.default_template_extension}"
 
       # ask to overwrite file
       if File.exist?(demo_report_file)

data/lib/grafana_reporter/csv_table_format_strategy.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module GrafanaReporter
+  # Implements a default table format strategy, which will return tables
+  # as CSV formatted strings.
+  class CsvTableFormatStrategy < AbstractTableFormatStrategy
+    # @see AbstractTableFormatStrategy#abbreviation
+    def self.abbreviation
+      'csv'
+    end
+
+    # @see AbstractTableFormatStrategy#format
+    def format(result, include_headline)
+      headline = result[:header].map { |item| item.to_s.gsub(',', '\\,') }.join(',')
+
+      content = result[:content].map do |row|
+        row.map { |item| item.to_s.gsub(',', '\,') }.join(',')
+      end.join("\n")
+
+      "#{"#{headline}\n" if include_headline}#{content}"
+    end
+  end
+end

data/lib/grafana_reporter/demo_report_wizard.rb

@@ -55,7 +55,11 @@ module GrafanaReporter
       results = {}
 
       dashboard.panels.shuffle.each do |panel|
-        next if panel.datasource.is_a?(Grafana::UnsupportedDatasource)
+        begin
+          next if panel.datasource.is_a?(Grafana::UnsupportedDatasource)
+        rescue Grafana::DatasourceDoesNotExistError
+          next
+        end
 
         query_classes.each do |query_class|
           unless query_class.public_instance_methods.include?(:build_demo_entry)
@@ -80,7 +84,6 @@ module GrafanaReporter
       results
     end
 
-    # TODO: move this method to Asciidoctor::Report
     def format_results(raw_results)
       results = ['= Demo report',
                  "Created by `+ruby-grafana-reporter+` version #{GRAFANA_REPORTER_VERSION.join('.')}",

data/lib/grafana_reporter/erb/demo_report_builder.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module GrafanaReporter
+  module ERB
+    # This class builds a demo report for ERB templates
+    class DemoReportBuilder
+      # This method is called if a demo report shall be built for the given {Grafana::Panel}.
+      # @param panel [Grafana::Panel] panel object, for which a demo entry shall be created.
+      # @return [String] String containing the entry, or nil if not possible for given panel
+      def build_demo_entry(panel)
+        return nil unless panel
+        return nil unless panel.model['type'].include?('table')
+
+        ref_id = nil
+        panel.model['targets'].each do |item|
+          if !item['hide'] && !panel.query(item['refId']).to_s.empty?
+            ref_id = item['refId']
+            break
+          end
+        end
+        return nil unless ref_id
+
+        <<~DEMO_ERB_TEMPLATE
+          <%
+          dashboard = '#{panel.dashboard.id}'
+          instance = 'default'
+          # load the panel object from grafana instance
+          panel = @report.grafana(instance).dashboard(dashboard).panel(#{panel.id})
+          # build a complete attributes hash, including the variables set for this report call
+          # e.g. including command line parameters etc.
+          attrs = @attributes.merge({ 'result_type' => 'panel_table', 'query' => '#{ref_id}' })
+          query = QueryValueQuery.new(panel, variables: attrs)
+          %>
+
+          This is a test table for panel <%= panel.id %>:
+
+          <%= query.execute %>
+
+          For detailed API documentation you may start with:
+            1) the AbstractReport (https://rubydoc.info/gems/ruby-grafana-reporter/GrafanaReporter/AbstractReport), or
+            2) subclasses of the AbstractQuery (https://rubydoc.info/gems/ruby-grafana-reporter/GrafanaReporter/AbstractQuery)
+        DEMO_ERB_TEMPLATE
+      end
+    end
+  end
+end

data/lib/grafana_reporter/erb/report.rb

@@ -9,34 +9,27 @@ module GrafanaReporter
     class Report < ::GrafanaReporter::AbstractReport
       # Starts to create an asciidoctor report. It utilizes all extensions in the {GrafanaReporter::Asciidoctor}
       # namespace to realize the conversion.
-      # @see AbstractReport#create_report
-      def create_report(template, destination_file_or_path = nil, custom_attributes = {})
-        super
-        attrs = @config.default_document_attributes.merge(@custom_attributes)
+      # @see AbstractReport#build
+      def build
+        attrs = @config.default_document_attributes.merge(@custom_attributes).merge({ 'grafana_report_timestamp' => ::Grafana::Variable.new(Time.now.to_s) })
         logger.debug("Document attributes: #{attrs}")
 
-        # TODO: if path is true, a default filename has to be generated. check if this should be a general function instead
-        @report = self
-        File.write(path, ::ERB.new(File.read(template)).result(binding))
+        File.write(path, ::ERB.new(File.read(@template)).result(ReportJail.new(self, attrs).bind))
+      end
+
+      # @see AbstractReport#default_template_extension
+      def self.default_template_extension
+        'erb'
+      end
 
-        # TODO: check if closing output file is correct here, or maybe can be moved to AbstractReport.done!
-        @destination_file_or_path.close if @destination_file_or_path.is_a?(File)
-      rescue MissingTemplateError => e
-        @logger.error(e.message)
-        @error = [e.message]
-        done!
-        raise e
-      rescue StandardError => e
-        # catch all errors during execution
-        died_with_error(e)
-        raise e
-      ensure
-        done!
+      # @see AbstractReport#default_result_extension
+      def self.default_result_extension
+        'txt'
       end
 
       # @see AbstractReport#demo_report_classes
       def self.demo_report_classes
-        []
+        [DemoReportBuilder]
       end
     end
   end