ruby-grafana-reporter 0.4.2 → 0.5.0

data/lib/grafana/variable.rb

@@ -29,14 +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']
-        unless @config['current'].nil?
-          @raw_value = @config['current']['value']
-          @text = @config['current']['text']
-        end
+        init_values
       else
         @config = {}
         @raw_value = config_or_value
@@ -62,93 +62,105 @@ module Grafana
     def value_formatted(format = '')
       value = @raw_value
 
-      # handle value 'All' properly
-      # TODO: fix check for selection of All properly
-      if (value == 'All') || (@text == 'All')
+      # if 'All' is selected for this template variable, capture all values properly
+      # (from grafana config or query) and format the results afterwards accordingly
+      if value == '$__all'
         if !@config['options'].empty?
-          value = @config['options'].map { |item| item['value'] }
-        elsif !@config['query'].empty?
-          # TODO: replace variables in this query, too
-          return @config['query']
-          # TODO: handle 'All' value properly for query attributes
+          # this query contains predefined values, so capture them and format the values accordingly
+          # 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?
+          # 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: how to handle All selection properly at this point?
+          # TODO: add support for variable type: 'datasource' and 'adhoc'
         end
       end
 
       case format
       when 'csv'
-        return value.join(',').to_s if multi?
+        return value.join(',').to_s if multi? && value.is_a?(Array)
 
         value.to_s
 
       when 'distributed'
-        return value.join(",#{name}=") if multi?
+        return value.join(",#{name}=") if multi? && value.is_a?(Array)
 
         value
       when 'doublequote'
-        if multi?
+        if multi? && value.is_a?(Array)
           value = value.map { |item| "\"#{item.gsub(/\\/, '\\\\').gsub(/"/, '\\"')}\"" }
           return value.join(',')
         end
         "\"#{value.gsub(/"/, '\\"')}\""
 
       when 'json'
-        if multi?
+        if multi? && value.is_a?(Array)
           value = value.map { |item| "\"#{item.gsub(/["\\]/, '\\\\\0')}\"" }
           return "[#{value.join(',')}]"
         end
         "\"#{value.gsub(/"/, '\\"')}\""
 
       when 'percentencode'
-        value = "{#{value.join(',')}}" if multi?
+        value = "{#{value.join(',')}}" if multi? && value.is_a?(Array)
         ERB::Util.url_encode(value)
 
       when 'pipe'
-        return value.join('|') if multi?
+        return value.join('|') if multi? && value.is_a?(Array)
 
         value
 
       when 'raw'
-        return "{#{value.join(',')}}" if multi?
+        return "{#{value.join(',')}}" if multi? && value.is_a?(Array)
 
         value
 
       when 'regex'
-        if multi?
+        if multi? && value.is_a?(Array)
           value = value.map { |item| item.gsub(%r{[/$.|\\]}, '\\\\\0') }
           return "(#{value.join('|')})"
         end
         value.gsub(%r{[/$.|\\]}, '\\\\\0')
 
       when 'singlequote'
-        if multi?
+        if multi? && value.is_a?(Array)
           value = value.map { |item| "'#{item.gsub(/'/, '\\\\\0')}'" }
           return value.join(',')
         end
         "'#{value.gsub(/'/, '\\\\\0')}'"
 
       when 'sqlstring'
-        if multi?
+        if multi? && value.is_a?(Array)
           value = value.map { |item| "'#{item.gsub(/'/, "''")}'" }
           return value.join(',')
         end
         "'#{value.gsub(/'/, "''")}'"
 
       when 'lucene'
-        if multi?
+        if multi? && value.is_a?(Array)
           value = value.map { |item| "\"#{item.gsub(%r{[" |=/\\]}, '\\\\\0')}\"" }
           return "(#{value.join(' OR ')})"
         end
         value.gsub(%r{[" |=/\\]}, '\\\\\0')
 
       when /^date(?::(?<format>.*))?$/
-        # TODO: validate how grafana handles multivariables with date format
-        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
-        if multi?
+        if multi? && value.is_a?(Array)
           value = value.map { |item| "'#{item.gsub(/'/, "''")}'" }
           return value.join(',')
         end
@@ -162,8 +174,9 @@ module Grafana
       end
     end
 
-    # @return [Boolean] true, if the value can contain multiple selections, i.e. is 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
@@ -181,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')
 
@@ -196,12 +210,13 @@ module Grafana
       until work_string.empty?
         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)
+
         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
 
@@ -213,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

data/lib/grafana_reporter/abstract_query.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative 'abstract_table_format_strategy'
+require_relative 'csv_table_format_strategy'
+
 module GrafanaReporter
   # @abstract Override {#pre_process} and {#post_process} in subclass.
   #
@@ -10,7 +13,7 @@ module GrafanaReporter
     attr_reader :variables, :result, :panel, :dashboard
 
     def timeout
-      # TODO: check where value priorities should be evaluated
+      # TODO: PRIO check where value priorities should be evaluated
       return @variables['timeout'].raw_value if @variables['timeout']
       return @variables['grafana_default_timeout'].raw_value if @variables['grafana_default_timeout']
 
@@ -41,6 +44,7 @@ module GrafanaReporter
       else
         raise GrafanaReporterError, "Internal error in AbstractQuery: given object is of type #{grafana_obj.class.name}, which is not supported"
       end
+      @logger = @grafana ? @grafana.logger : ::Logger.new($stderr, level: :info)
       @variables = {}
       @variables['from'] = Grafana::Variable.new(nil)
       @variables['to'] = Grafana::Variable.new(nil)
@@ -76,7 +80,7 @@ module GrafanaReporter
       raise DatasourceNotSupportedError.new(@datasource, self) if @datasource.is_a?(Grafana::UnsupportedDatasource)
 
       begin
-        @result = @datasource.request(from: from, to: to, raw_query: raw_query, variables: grafana_variables,
+        @result = @datasource.request(from: from, to: to, raw_query: raw_query, variables: @variables,
                                       prepared_request: @grafana.prepare_request, timeout: timeout)
       rescue ::Grafana::GrafanaError
         # grafana errors will be directly passed through
@@ -89,6 +93,7 @@ module GrafanaReporter
       end
 
       raise DatasourceRequestInvalidReturnValueError.new(@datasource, @result) unless datasource_response_valid?
+
       post_process
       @result
     end
@@ -139,6 +144,8 @@ module GrafanaReporter
     #
     # Multiple columns may be filtered. Therefore the column titles have to be named in the
     # {Grafana::Variable#raw_value} and have to be separated by +,+ (comma).
+    #
+    # Commas can be used in a format string, but need to be escaped by using +_,+.
     # @param result [Hash] preformatted sql hash, (see {Grafana::AbstractDatasource#request})
     # @param filter_columns_variable [Grafana::Variable] column names, which shall be removed in the query result
     # @return [Hash] filtered query result
@@ -146,8 +153,8 @@ module GrafanaReporter
       return result unless filter_columns_variable
 
       filter_columns = filter_columns_variable.raw_value
-      filter_columns.split(',').each do |filter_column|
-        pos = result[:header].index(filter_column)
+      filter_columns.split(/(?<!_),/).each do |filter_column|
+        pos = result[:header].index(filter_column.gsub("_,", ","))
 
         unless pos.nil?
           result[:header].delete_at(pos)
@@ -163,23 +170,33 @@ module GrafanaReporter
     # The formatting will be applied separately for every column. Therefore the column formats have to be named
     # in the {Grafana::Variable#raw_value} and have to be separated by +,+ (comma). If no value is specified for
     # a column, no change will happen.
+    #
+    # It is also possible to format milliseconds as dates by specifying date formats, e.g. +date:iso+. It is
+    # possible to use any date format according
+    # {https://grafana.com/docs/grafana/latest/variables/variable-types/global-variables/#from-and-to}
+    #
+    # Commas can be used in a format string, but need to be escaped by using +_,+.
     # @param result [Hash] preformatted sql hash, (see {Grafana::AbstractDatasource#request})
     # @param formats [Grafana::Variable] formats, which shall be applied to the columns in the query result
     # @return [Hash] formatted query result
     def format_columns(result, formats)
       return result unless formats
 
-      formats.text.split(',').each_index do |i|
-        format = formats.text.split(',')[i]
+      formats.text.split(/(?<!_),/).each_index do |i|
+        format = formats.text.split(/(?<!_),/)[i].gsub("_,", ",")
         next if format.empty?
 
         result[:content].map do |row|
           next unless row.length > i
 
           begin
-            row[i] = format % row[i] if row[i]
+            if format =~ /^date:/
+              row[i] = ::Grafana::Variable.format_as_date(row[i], format.sub(/^date:/, '')) if row[i]
+            else
+              row[i] = format % row[i] if row[i]
+            end
           rescue StandardError => e
-            @grafana.logger.error(e.message)
+            @logger.error(e.message)
             row[i] = e.message
           end
         end
@@ -216,7 +233,6 @@ module GrafanaReporter
     # @param result [Hash] preformatted query result (see {Grafana::AbstractDatasource#request}.
     # @param configs [Array<Grafana::Variable>] one variable for replacing values in one column
     # @return [Hash] query result with replaced values
-    # TODO: make sure that caught errors are also visible in logger
     def replace_values(result, configs)
       return result if configs.empty?
 
@@ -231,8 +247,11 @@ module GrafanaReporter
 
           k = arr[0]
           v = arr[1]
-          k.gsub!(/\\([:,])/, '\1')
-          v.gsub!(/\\([:,])/, '\1')
+
+          # allow keys and values to contain escaped colons or commas
+          k = k.gsub(/\\([:,])/, '\1')
+          v = v.gsub(/\\([:,])/, '\1')
+
           result[:content].map do |row|
             (row.length - 1).downto 0 do |i|
               if cols.include?(i + 1) || cols.empty?
@@ -242,7 +261,7 @@ module GrafanaReporter
                   begin
                     row[i] = row[i].to_s.gsub(/#{k}/, v) if row[i].to_s =~ /#{k}/
                   rescue StandardError => e
-                    @grafana.logger.error(e.message)
+                    @logger.error(e.message)
                     row[i] = e.message
                   end
 
@@ -267,6 +286,7 @@ module GrafanaReporter
                                  end
                       end
                     rescue StandardError => e
+                      @logger.error(e.message)
                       row[i] = e.message
                     end
                   end
@@ -284,22 +304,34 @@ module GrafanaReporter
       result
     end
 
-    # Used to build a output format matching the requested report format.
+    # Used to build a table output in a custom format.
     # @param result [Hash] preformatted sql hash, (see {Grafana::AbstractDatasource#request})
     # @param opts [Hash] options for the formatting:
-    # @option opts [Grafana::Variable] :row_divider requested row divider for the result table
-    # @option opts [Grafana::Variable] :column_divider requested row divider for the result table
-    # @option opts [Regex or String] :escape_regex regular expression which specifies a part of a cell content, which has to be escaped
-    # @option opts [String] :escape_replacement specifies how the found :escape_regex shall be replaced
-    # @return [String] formatted table result in requested output format
+    # @option opts [Grafana::Variable] :row_divider requested row divider for the result table, only to be used with table_formatter `adoc_deprecated`
+    # @option opts [Grafana::Variable] :column_divider requested row divider for the result table, only to be used with table_formatter `adoc_deprecated`
+    # @option opts [Grafana::Variable] :include_headline specifies if table should contain headline, defaults to false
+    # @option opts [Grafana::Variable] :table_formatter specifies which formatter shall be used, defaults to 'csv'
+    # @option opts [Grafana::Variable] :transposed specifies whether the result table is transposed
+    # @return [String] table in custom output format
     def format_table_output(result, opts)
-      opts = { escape_regex: '|', escape_replacement: '\\|', row_divider: Grafana::Variable.new('| '), column_divider: Grafana::Variable.new(' | ') }.merge(opts.delete_if {|_k, v| v.nil? })
-
-      result[:content].map do |row|
-        opts[:row_divider].raw_value + row.map do |item|
-          item.to_s.gsub(opts[:escape_regex], opts[:escape_replacement])
-        end.join(opts[:column_divider].raw_value)
+      opts = { include_headline: Grafana::Variable.new('false'),
+               table_formatter: Grafana::Variable.new('csv'),
+               row_divider: Grafana::Variable.new('| '),
+               column_divider: Grafana::Variable.new(' | '),
+               transpose: Grafana::Variable.new('false') }.merge(opts.delete_if {|_k, v| v.nil? })
+
+      if opts[:table_formatter].raw_value == 'adoc_deprecated'
+        @logger.warn("You are using deprecated 'table_formatter' named 'adoc_deprecated', which will be "\
+                     "removed in a future version. Start using 'adoc_plain' or register your own "\
+                     "implementation of AbstractTableFormatStrategy.")
+        return result[:content].map do |row|
+          opts[:row_divider].raw_value + row.map do |item|
+            item.to_s.gsub('|', '\\|')
+          end.join(opts[:column_divider].raw_value)
+        end.join("\n")
       end
+
+      AbstractTableFormatStrategy.get(opts[:table_formatter].raw_value).format(result, opts[:include_headline].raw_value.downcase == 'true', opts[:transpose].raw_value.downcase == 'true')
     end
 
     # Used to translate the relative date strings used by grafana, e.g. +now-5d/w+ to the
@@ -317,9 +349,10 @@ module GrafanaReporter
     # @param timezone [Grafana::Variable] timezone to use, if not system timezone
     # @return [String] translated date as timestamp string
     def translate_date(orig_date, report_time, is_to_time, timezone = nil)
-      # TODO: add test case for creation of variable, if not given, maybe also print a warning
+      @logger.warn("#translate_date has been called without 'report_time' - using current time as fallback.") unless report_time
       report_time ||= ::Grafana::Variable.new(Time.now.to_s)
       orig_date = orig_date.raw_value if orig_date.is_a?(Grafana::Variable)
+
       return (DateTime.parse(report_time.raw_value).to_time.to_i * 1000).to_s unless orig_date
       return orig_date if orig_date =~ /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/
       return orig_date if orig_date =~ /^\d+$/
@@ -327,24 +360,24 @@ module GrafanaReporter
       # check if a relative date is mentioned
       date_spec = orig_date.clone
 
-      date_spec.slice!(/^now/)
+      date_spec = date_spec.gsub(/^now/, '')
       raise TimeRangeUnknownError, orig_date unless date_spec
 
       date = DateTime.parse(report_time.raw_value)
-      # TODO: allow from_translated or similar in ADOC template
+      # TODO: PRIO allow from_translated or similar in ADOC template
       date = date.new_offset(timezone.raw_value) if timezone
 
       until date_spec.empty?
         fit_match = date_spec.match(%r{^/(?<fit>[smhdwMy])})
         if fit_match
           date = fit_date(date, fit_match[:fit], is_to_time)
-          date_spec.slice!(%r{^/#{fit_match[:fit]}})
+          date_spec = date_spec.gsub(%r{^/#{fit_match[:fit]}}, '')
         end
 
         delta_match = date_spec.match(/^(?<op>(?:-|\+))(?<count>\d+)?(?<unit>[smhdwMy])/)
         if delta_match
           date = delta_date(date, "#{delta_match[:op]}#{delta_match[:count] || 1}".to_i, delta_match[:unit])
-          date_spec.slice!(/^#{delta_match[:op]}#{delta_match[:count]}#{delta_match[:unit]}/)
+          date_spec = date_spec.gsub(/^#{delta_match[:op]}#{delta_match[:count]}#{delta_match[:unit]}/, '')
         end
 
         raise TimeRangeUnknownError, orig_date unless fit_match || delta_match
@@ -387,22 +420,15 @@ module GrafanaReporter
     def datasource_response_valid?
       return false if @result.nil?
       return false unless @result.is_a?(Hash)
-      # TODO: check if it should be ok if a datasource request returns an empty hash only
-      return true if @result.empty?
-      return false unless @result.has_key?(:header)
-      return false unless @result.has_key?(:content)
+      return false if @result.empty?
+      return false unless @result.key?(:header)
+      return false unless @result.key?(:content)
       return false unless @result[:header].is_a?(Array)
       return false unless @result[:content].is_a?(Array)
 
       true
     end
 
-    # @return [Hash<String, Variable>] all grafana variables stored in this query, i.e. the variable name
-    #  is prefixed with +var-+
-    def grafana_variables
-      @variables.select { |k, _v| k =~ /^var-.+/ }
-    end
-
     def delta_date(date, delta_count, time_letter)
       # substract specified time
       case time_letter

data/lib/grafana_reporter/abstract_report.rb

@@ -126,7 +126,7 @@ module GrafanaReporter
 
     # Is being called to start the report generation. To execute the specific report generation, this function
     # calls the abstract {#build} method with the given parameters.
-    # @param template [String] path to the template to be used, trailing +.adoc+ extension may be omitted
+    # @param template [String] path to the template to be used, trailing extension may be omitted, whereas {#default_template_extension} will be appended
     # @param destination_file_or_path [String or File] path to the destination report or file object to use
     # @param custom_attributes [Hash] custom attributes, which shall be merged with priority over the configuration
     # @return [void]
@@ -136,14 +136,16 @@ module GrafanaReporter
       @destination_file_or_path = destination_file_or_path
       @custom_attributes = custom_attributes
 
-      # automatically add extension, if a file with adoc extension exists
-      @template = "#{@template}.adoc" if File.file?("#{@template}.adoc") && !File.file?(@template.to_s)
+      # automatically add extension, if a file with default template extension exists
+      @template = "#{@template}.#{self.class.default_template_extension}" if File.file?("#{@template}.#{self.class.default_template_extension}") && !File.file?(@template.to_s)
       raise MissingTemplateError, @template.to_s unless File.file?(@template.to_s)
 
       notify(:on_before_create)
       @start_time = Time.new
       logger.info("Report started at #{@start_time}")
-      build(template, destination_file_or_path, custom_attributes)
+      logger.info("You are running ruby-grafana-reporter version #{GRAFANA_REPORTER_VERSION.join('.')}.")
+      logger.info("A newer version is released. Check out https://github.com/divinity666/ruby-grafana-reporter/releases/latest") unless @config.latest_version_check_ok?
+      build
     rescue MissingTemplateError => e
       @logger.error(e.message)
       @error = [e.message]
@@ -186,6 +188,18 @@ module GrafanaReporter
       raise NotImplementedError
     end
 
+    # @abstract
+    # @return [String] specifying the default extension of a template file
+    def self.default_template_extension
+      raise NotImplementedError
+    end
+
+    # @abstract
+    # @return [String] specifying the default extension of a rendered result file
+    def self.default_result_extension
+      raise NotImplementedError
+    end
+
     private
 
     # Called, if the report generation has died with an error.
@@ -207,6 +221,7 @@ module GrafanaReporter
     def done!
       return if @done
 
+      @destination_file_or_path.close if @destination_file_or_path.is_a?(File)
       @done = true
       @end_time = Time.new
       @start_time ||= @end_time

data/lib/grafana_reporter/abstract_table_format_strategy.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module GrafanaReporter
+  # The abstract base class, which is to be implemented for different table
+  # output formats. By implementing this class, you e.g. can decide if a table
+  # will be formatted as CSV, JSON or any other format.
+  class AbstractTableFormatStrategy
+    @@subclasses = []
+
+    def self.inherited(obj)
+      @@subclasses << obj
+    end
+
+    # @param abbreviation [String] name of the requested table format strategy
+    # @return [AbstractTableFormatStrategy] fitting strategy instance for the given name
+    def self.get(abbreviation)
+      @@subclasses.select { |item| item.abbreviation == abbreviation }.first.new
+    end
+
+    # @abstract
+    # @return [String] short name of the current stategy, under which it shall be accessible
+    def self.abbreviation
+      raise NotImplementedError
+    end
+
+    # Used to format a given content array to the desired output format. The default
+    # implementation applies the {#format_rules} to create a custom string export. If
+    # this is not sufficient for a desired table format, you may simply overwrite this
+    # function to have full freedom about the desired output.
+    # @param content [Hash] datasource table result
+    # @param include_headline [Boolean] true, if headline should be included in result
+    # @param transposed [Boolean] true, if result array is in transposed format
+    # @return [String] formatted in table format
+    def format(content, include_headline, transposed)
+      result = content[:content]
+
+      # add the headline at the correct position to the content array
+      if include_headline
+        if transposed
+          result.each_index do |i|
+            result[i] = [content[:header][i]] + result[i]
+          end
+        else
+          result = result.unshift(content[:header])
+        end
+      end
+
+      # translate the content to a table
+      result.map do |row|
+        format_rules[:row_start] + row.map do |item|
+          value = item.to_s
+          if format_rules[:replace_string_or_regex]
+            value = value.gsub(format_rules[:replace_string_or_regex], format_rules[:replacement])
+          end
+
+          format_rules[:cell_start] + value + format_rules[:cell_end]
+        end.join(format_rules[:between_cells])
+      end.join(format_rules[:row_end])
+    end
+
+    # Formatting rules, which are applied to build the table output format.
+    def format_rules
+      {
+        row_start: '',
+        row_end: '',
+        cell_start: '',
+        between_cells: '',
+        cell_end: '',
+        replace_string_or_regex: nil,
+        replacement: ''
+      }
+    end
+  end
+end

data/lib/grafana_reporter/alerts_table_query.rb

@@ -33,7 +33,12 @@ module GrafanaReporter
       @result = replace_values(@result, @variables.select { |k, _v| k =~ /^replace_values_\d+/ })
       @result = filter_columns(@result, @variables['filter_columns'])
 
-      @result = format_table_output(@result, row_divider: @variables['row_divider'], column_divider: @variables['column_divider'])
+      @result = format_table_output(@result,
+                                    row_divider: @variables['row_divider'],
+                                    column_divider: @variables['column_divider'],
+                                    table_formatter: @variables['table_formatter'],
+                                    include_headline: @variables['include_headline'],
+                                    transpose: @variables['transpose'])
     end
   end
 end

data/lib/grafana_reporter/annotations_table_query.rb

@@ -32,7 +32,12 @@ module GrafanaReporter
       @result = replace_values(@result, @variables.select { |k, _v| k =~ /^replace_values_\d+/ })
       @result = filter_columns(@result, @variables['filter_columns'])
 
-      @result = format_table_output(@result, row_divider: @variables['row_divider'], column_divider: @variables['column_divider'])
+      @result = format_table_output(@result,
+                                    row_divider: @variables['row_divider'],
+                                    column_divider: @variables['column_divider'],
+                                    table_formatter: @variables['table_formatter'],
+                                    include_headline: @variables['include_headline'],
+                                    transpose: @variables['transpose'])
     end
   end
 end

data/lib/grafana_reporter/application/application.rb

@@ -13,7 +13,6 @@ module GrafanaReporter
     # It can be run to test the grafana connection, render a single template
     # or run as a service.
     class Application
-
       # Contains the {Configuration} object of the application.
       attr_accessor :config
 
@@ -140,7 +139,13 @@ module GrafanaReporter
 
         when Configuration::MODE_SINGLE_RENDER
           begin
-            config.report_class.new(config).create_report(config.template, config.to_file)
+            template_ext = config.report_class.default_template_extension
+            report_ext = config.report_class.default_result_extension
+            default_to_file = File.basename(config.template.to_s.gsub(/(?:\.#{template_ext})?$/, ".#{report_ext}"))
+
+            to_file = config.to_file
+            to_file = "#{config.reports_folder}#{default_to_file}" if to_file == true
+            config.report_class.new(config).create_report(config.template, to_file)
           rescue StandardError => e
             puts "#{e.message}\n#{e.backtrace.join("\n")}"
           end