ruby-grafana-reporter 0.1.7 → 0.4.0

data/lib/grafana_reporter/application/errors.rb

@@ -1,30 +1,33 @@
-module GrafanaReporter
-  module Application
-    # General grafana application error, from which the specific errors
-    # inherit.
-    class ApplicationError < GrafanaReporterError
-    end
-
-    # Thrown if a non existing template has been specified.
-    class MissingTemplateError < ApplicationError
-      def initialize(template)
-        super("Given report template '#{template}' is not a valid template.")
-      end
-    end
-
-    # Thrown, if a webservice request has been requested, which could not be
-    # handled.
-    class WebserviceUnknownPathError < ApplicationError
-      def initialize(request)
-        super("Request '#{request}' calls an unknown path for this webservice.")
-      end
-    end
-
-    # Thrown, if an internal error appeared during creation of the report.
-    class WebserviceGeneralRenderingError < ApplicationError
-      def initialize(error)
-        super("Could not render report because of internal error: #{error}")
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module GrafanaReporter
+  module Application
+    # General grafana application error, from which the specific errors
+    # inherit.
+    class ApplicationError < GrafanaReporterError
+    end
+
+    # Thrown, if the '-s' parameter is not configured with exactly one variable
+    # name and one value.
+    class ParameterValueError < ApplicationError
+      def initialize(length)
+        super("Parameter '-s' needs exactly two values separated by comma, received #{length}.")
+      end
+    end
+
+    # Thrown, if a webservice request has been requested, which could not be
+    # handled.
+    class WebserviceUnknownPathError < ApplicationError
+      def initialize(request)
+        super("Request '#{request}' calls an unknown path for this webservice.")
+      end
+    end
+
+    # Thrown, if an internal error appeared during creation of the report.
+    class WebserviceGeneralRenderingError < ApplicationError
+      def initialize(error)
+        super("Could not render report because of internal error: #{error}")
+      end
+    end
+  end
+end

data/lib/grafana_reporter/application/webservice.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+module GrafanaReporter
+  module Application
+    # This class provides the webservice for the reporter application. It does not
+    # make use of `webrick` or similar, so that it can be used without futher dependencies
+    # in conjunction with the standard asciidoctor docker container.
+    class Webservice
+      def initialize
+        @reports = []
+        @running = false
+      end
+
+      # Runs the webservice with the given {Configuration} object.
+      def run(config)
+        @config = config
+        @logger = config.logger
+
+        # start webserver
+        @server = TCPServer.new(@config.webserver_port)
+        @logger.info("Server listening on port #{@config.webserver_port}...")
+        @running = true
+
+        @progress_reporter = Thread.new {}
+
+        accept_requests_loop
+        @running = false
+      end
+
+      # @return True, if webservice is up and running, false otherwise
+      def running?
+        @running
+      end
+
+      private
+
+      def accept_requests_loop
+        loop do
+          # step 1) accept incoming connection
+          socket = @server.accept
+
+          # step 2) print the request headers (separated by a blank line e.g. \r\n)
+          request = ''
+          line = ''
+          begin
+            until line == "\r\n"
+              line = socket.readline
+              request += line
+            end
+          rescue EOFError => e
+            @logger.debug("Webserver EOFError: #{e.message}")
+          end
+
+          begin
+            response = handle_request(request)
+            socket.write response
+          rescue WebserviceUnknownPathError => e
+            @logger.debug(e.message)
+            socket.write http_response(404, '', e.message)
+          rescue MissingTemplateError => e
+            @logger.error(e.message)
+            socket.write http_response(400, 'Bad Request', e.message)
+          rescue WebserviceGeneralRenderingError => e
+            @logger.fatal(e.message)
+            socket.write http_response(400, 'Bad Request', e.message)
+          rescue StandardError => e
+            @logger.fatal(e.message)
+            socket.write http_response(400, 'Bad Request', e.message)
+          ensure
+            socket.close
+          end
+
+          log_report_progress
+          clean_outdated_temporary_reports
+        end
+      end
+
+      def log_report_progress
+        return if @progress_reporter.alive?
+
+        @progress_reporter = Thread.new do
+          running_reports = @reports.reject(&:done)
+          until running_reports.empty?
+            unless running_reports.empty?
+              @logger.info("#{running_reports.length} report(s) in progress: "\
+                           "#{running_reports.map do |report|
+                                "#{(report.progress * 100).to_i}% (running #{report.execution_time.to_i} secs)"
+                              end.join(', ')}")
+            end
+            sleep 5
+            running_reports = @reports.reject(&:done)
+          end
+          # puts "no more running reports - stopping to report progress"
+        end
+      end
+
+      def clean_outdated_temporary_reports
+        clean_time = Time.now - 60 * 60 * @config.report_retention
+        @reports.select { |report| report.done && clean_time > report.end_time }.each do |report|
+          @reports.delete(report).delete_file
+        end
+      end
+
+      def handle_request(request)
+        raise WebserviceUnknownPathError, request.split("\r\n")[0] if request.nil?
+        raise WebserviceUnknownPathError, request.split("\r\n")[0] if request.split("\r\n")[0].nil?
+
+        query_string = request.split("\r\n")[0].gsub(%r{(?:[^?]+\?)(.*)(?: HTTP/.*)$}, '\1')
+        query_parameters = CGI.parse(query_string)
+
+        @logger.debug("Received request: #{request.split("\r\n")[0]}")
+        @logger.debug("query_parameters: #{query_parameters}")
+
+        # read URL parameters
+        attrs = {}
+        query_parameters.each do |k, v|
+          attrs[k] = v.length == 1 ? v[0] : v
+        end
+
+        case request.split("\r\n")[0]
+        when %r{^GET /render[? ]}
+          return render_report(attrs)
+
+        when %r{^GET /overview[? ]}
+          # show overview for current reports
+          return get_reports_status_as_html(@reports)
+
+        when %r{^GET /view_report[? ]}
+          return view_report(attrs)
+
+        when %r{^GET /cancel_report[? ]}
+          return cancel_report(attrs)
+
+        when %r{^GET /view_log[? ]}
+          return view_log(attrs)
+        end
+
+        raise WebserviceUnknownPathError, request.split("\r\n")[0]
+      end
+
+      def view_log(attrs)
+        # view report if already available, or show status view
+        report = @reports.select { |r| r.object_id.to_s == attrs['report_id'].to_s }.first
+        raise WebserviceGeneralRenderingError, 'view_log has been called without valid id' if report.nil?
+
+        content = report.full_log
+
+        http_response(200, 'OK', content, "Content-Type": 'text/plain')
+      end
+
+      def cancel_report(attrs)
+        # view report if already available, or show status view
+        report = @reports.select { |r| r.object_id.to_s == attrs['report_id'].to_s }.first
+        raise WebserviceGeneralRenderingError, 'cancel_report has been called without valid id' if report.nil?
+
+        report.cancel! unless report.done
+
+        # redirect to view_report page
+        http_response(302, 'Found', nil, Location: "/view_report?report_id=#{report.object_id}")
+      end
+
+      def view_report(attrs)
+        # view report if already available, or show status view
+        report = @reports.select { |r| r.object_id.to_s == attrs['report_id'].to_s }.first
+        raise WebserviceGeneralRenderingError, 'view_report has been called without valid id' if report.nil?
+
+        # show report status
+        return get_reports_status_as_html([report]) if !report.done || !report.error.empty?
+
+        # provide report
+        @logger.debug("Returning PDF report at #{report.path}")
+        content = File.read(report.path, mode: 'rb')
+        return http_response(200, 'OK', content, "Content-Type": 'application/pdf') if content.start_with?('%PDF')
+
+        http_response(200, 'OK', content, "Content-Type": 'application/octet-stream',
+                                          "Content-Disposition": 'attachment; '\
+                                                                 "filename=report_#{attrs['report_id']}.zip")
+      end
+
+      def render_report(attrs)
+        # build report
+        template_file = "#{@config.templates_folder}#{attrs['var-template']}.adoc"
+
+        file = Tempfile.new('gf_pdf_', @config.reports_folder)
+        begin
+          FileUtils.chmod('+r', file.path)
+        rescue StandardError => e
+          @logger.debug("File permissions could not be set for #{file.path}: #{e.message}")
+        end
+
+        report = @config.report_class.new(@config, template_file, file, attrs)
+        Thread.new do
+          report.create_report
+        end
+        @reports << report
+
+        http_response(302, 'Found', nil, Location: "/view_report?report_id=#{report.object_id}")
+      end
+
+      def get_reports_status_as_html(reports)
+        i = reports.length
+
+        content = '<html>'\
+                  '<head></head>'\
+                  '<body>'\
+                  '<table>'\
+                  '<thead>'\
+                  '<th>#</th>'\
+                  '<th>Start Time</th>'\
+                  '<th>End Time</th>'\
+                  '<th>Template</th>'\
+                  '<th>Execution time</th>'\
+                  '<th>Status</th>'\
+                  '<th>Error</th>'\
+                  '<th>Action</th>'\
+                  '</thead>' +
+                  reports.reverse.map do |report|
+                    '<tr>'\
+                    "<td>#{i -= 1}</td>"\
+                    "<td>#{report.start_time}</td>"\
+                    "<td>#{report.end_time}</td>"\
+                    "<td>#{report.template}</td>"\
+                    "<td>#{report.execution_time.to_i} secs</td>"\
+                    "<td>#{report.status} (#{(report.progress * 100).to_i}%)</td>"\
+                    "<td>#{report.error.join('<br>')}</td>"\
+                    "<td>#{!report.done && !report.cancel ? "<a href=\"/cancel_report?report_id=#{report.object_id}\">Cancel</a>&nbsp;" : ''}"\
+                    "#{(report.status == 'finished') || (report.status == 'cancelled') ? "<a href=\"/view_report?report_id=#{report.object_id}\">View</a>&nbsp;" : '&nbsp;'}"\
+                    "<a href=\"/view_log?report_id=#{report.object_id}\">Log</a></td>"\
+                    '</tr>'
+                  end.join('') +
+                  '</table></body></html>'
+
+        http_response(200, 'OK', content, "Content-Type": 'text/html')
+      end
+
+      def http_response(code, text, body, opts = {})
+        "HTTP/1.1 #{code} #{text}\r\n#{opts.map { |k, v| "#{k}: #{v}" }.join("\r\n")}"\
+        "#{body ? "\r\nContent-Length: #{body.to_s.bytesize}" : ''}\r\n\r\n#{body}"
+      end
+    end
+  end
+end

data/lib/grafana_reporter/asciidoctor/alerts_table_include_processor.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative 'processor_mixin'
+
+module GrafanaReporter
+  module Asciidoctor
+    # Implements the hook
+    #   include::grafana_alerts[<options>]
+    #
+    # Returns the results of alerts query as a asciidoctor table.
+    #
+    # == Used document parameters
+    # +grafana_default_instance+ - name of grafana instance, 'default' if not specified
+    #
+    # +grafana_default_dashboard+ - uid of grafana default dashboard to use
+    #
+    # +from+ - 'from' time for the sql query
+    #
+    # +to+ - 'to' time for the sql query
+    #
+    # == Supported options
+    # +columns+ - see {AlertsTableQuery#pre_process} (*mandatory*)
+    #
+    # +instance+ - name of grafana instance, 'default' if not specified
+    #
+    # +dashboard+ - uid of grafana dashboard to query for, empty string if no filter is wanted
+    #
+    # +panel+ - id of the panel to query for
+    #
+    # +from+ - 'from' time for the sql query
+    #
+    # +to+ - 'to' time for the sql query
+    #
+    # +format+ - see {QueryMixin#format_columns}
+    #
+    # +replace_values+ - see {QueryMixin#replace_values}
+    #
+    # +filter_columns+ - see {QueryMixin#filter_columns}
+    class AlertsTableIncludeProcessor < ::Asciidoctor::Extensions::IncludeProcessor
+      include ProcessorMixin
+
+      # :nodoc:
+      def handles?(target)
+        target.start_with? 'grafana_alerts'
+      end
+
+      # :nodoc:
+      def process(doc, reader, _target, attrs)
+        return if @report.cancel
+
+        @report.next_step
+        instance = attrs['instance'] || doc.attr('grafana_default_instance') || 'default'
+        dashboard_id = attrs['dashboard'] || doc.attr('grafana_default_dashboard')
+        panel_id = attrs['panel']
+        @report.logger.debug("Processing AlertsTableIncludeProcessor (instance: #{instance},"\
+                             " dashboard: #{dashboard_id}, panel: #{panel_id})")
+
+        query = AlertsTableQuery.new(@report.grafana(instance))
+        query.set_defaults_from_dashboard(@report.grafana(instance).dashboard(dashboard_id)) if dashboard_id
+        defaults = {}
+        defaults['dashboardId'] = dashboard_id if dashboard_id
+        defaults['panelId'] = panel_id if panel_id
+
+        query.merge_hash_variables(doc.attributes, attrs)
+        selected_attrs = attrs.select do |k, _v|
+          k =~ /(?:columns|limit|folderId|dashboardId|panelId|dahboardTag|dashboardQuery|state|query)/x
+        end
+        query.raw_query = defaults.merge(selected_attrs.each_with_object({}) { |(k, v), h| h[k] = v })
+        @report.logger.debug("from: #{query.from}, to: #{query.to}")
+
+        begin
+          reader.unshift_lines query.execute
+        rescue GrafanaReporterError => e
+          @report.logger.error(e.message)
+          reader.unshift_line "|#{e.message}"
+        rescue StandardError => e
+          @report.logger.fatal(e.message)
+          reader.unshift_line "|#{e.message}"
+        end
+
+        reader
+      end
+
+      # @see ProcessorMixin#build_demo_entry
+      def build_demo_entry(_panel)
+        "|===\ninclude::grafana_alerts[columns=\"panelId,name,state\"]\n|==="
+      end
+    end
+  end
+end

data/lib/grafana_reporter/asciidoctor/annotations_table_include_processor.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require_relative 'processor_mixin'
+
+module GrafanaReporter
+  module Asciidoctor
+    # Implements the hook
+    #   include::grafana_annotations[<options>]
+    #
+    # Returns the results of alerts query as a asciidoctor table.
+    #
+    # == Used document parameters
+    # +grafana_default_instance+ - name of grafana instance, 'default' if not specified
+    #
+    # +grafana_default_dashboard+ - uid of grafana default dashboard to use
+    #
+    # +from+ - 'from' time for the sql query
+    #
+    # +to+ - 'to' time for the sql query
+    #
+    # == Supported options
+    # +columns+ - see {AnnotationsTableQuery#pre_process} (*mandatory*)
+    #
+    # +instance+ - name of grafana instance, 'default' if not specified
+    #
+    # +dashboard+ - uid of grafana dashboard to query for, empty string if no filter is wanted
+    #
+    # +panel+ - id of the panel to query for
+    #
+    # +from+ - 'from' time for the sql query
+    #
+    # +to+ - 'to' time for the sql query
+    #
+    # +format+ - see {QueryMixin#format_columns}
+    #
+    # +replace_values+ - see {QueryMixin#replace_values}
+    #
+    # +filter_columns+ - see {QueryMixin#filter_columns}
+    class AnnotationsTableIncludeProcessor < ::Asciidoctor::Extensions::IncludeProcessor
+      include ProcessorMixin
+
+      # :nodoc:
+      def handles?(target)
+        target.start_with? 'grafana_annotations'
+      end
+
+      # :nodoc:
+      def process(doc, reader, _target, attrs)
+        return if @report.cancel
+
+        @report.next_step
+        instance = attrs['instance'] || doc.attr('grafana_default_instance') || 'default'
+        dashboard_id = attrs['dashboard'] || doc.attr('grafana_default_dashboard')
+        panel_id = attrs['panel']
+        @report.logger.debug("Processing AnnotationsTableIncludeProcessor (instance: #{instance})")
+
+        query = AnnotationsTableQuery.new(@report.grafana(instance))
+        query.set_defaults_from_dashboard(@report.grafana(instance).dashboard(dashboard_id)) if dashboard_id
+        defaults = {}
+        defaults['dashboardId'] = dashboard_id if dashboard_id
+        defaults['panelId'] = panel_id if panel_id
+
+        query.merge_hash_variables(doc.attributes, attrs)
+        selected_attrs = attrs.select do |k, _v|
+          k =~ /(?:columns|limit|alertId|dashboardId|panelId|userId|type|tags)/
+        end
+        query.raw_query = defaults.merge(selected_attrs.each_with_object({}) { |(k, v), h| h[k] = v })
+        @report.logger.debug("from: #{query.from}, to: #{query.to}")
+
+        begin
+          reader.unshift_lines query.execute
+        rescue GrafanaReporterError => e
+          @report.logger.error(e.message)
+          reader.unshift_line "|#{e.message}"
+        rescue StandardError => e
+          @report.logger.fatal(e.message)
+          reader.unshift_line "|#{e.message}"
+        end
+
+        reader
+      end
+
+      # @see ProcessorMixin#build_demo_entry
+      def build_demo_entry(_panel)
+        "|===\ninclude::grafana_annotations[columns=\"time,panelId,newState,prevState,text\"]\n|==="
+      end
+    end
+  end
+end