ruby-grafana-reporter 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ab1861d0ed6af7383a37bd357399451e38fb44d23489a52716660bae15a4f95
-  data.tar.gz: c744af8cd37f2fc469cef0d384d03e0610af5d38157a1367346f40986c29366c
+  metadata.gz: '06912db0a0635560dca75c00c01c047deac42741c7c6ba2ee717cbccdf26cb19'
+  data.tar.gz: 8d09e509266737bf1b73c3f6ad5c03255de461c116a6e5ec7b45bfaef56520b7
 SHA512:
-  metadata.gz: d15b706ffae42fb3cdd39fd1e9ffc83823102566a6cda208e6196dbca9f637a740043b2a022e3529c26433c095bd99fd569722a73f61b35ad2808a2508ada7c2
-  data.tar.gz: 140c0502ef9340136a7ff42614353b024a5ac70d6af65a1c9bae30034783dbedc41c8b066f3a7bca1142c3c00f24f632fcae5d85c84318de67afd36dc5ef6370
+  metadata.gz: 66e81686e253f8e98101f97b0b08db97f955cd1c274f2ed683f597b675c228adf198cd2c66f9ce3df05506a760564643e43b94c40fa952b13748122ecc8d6890
+  data.tar.gz: 916ec07231acf19c20b0f01d7bfe9a47d5825a8e0c3a6c67a9fa615e2b993343d1506fb129cc72b66e2be9b02102c15e338a6e8b5746286494de4164a9678c38

data/README.md

@@ -12,8 +12,13 @@ Reporting Service for Grafana
 * [Features](#features)
 * [Supported datasources](#supported-datasources)
 * [Quick Start](#quick-start)
-* [Grafana integration](#grafana-integration)
-* [Webservice overview](#webservice-overview)
+  * [Setup](#setup)
+  * [Grafana integration](#grafana-integration)
+* [Advanced information](#advanced-information)
+  * [Webservice](#webservice)
+  * [Using ERB templates](#using-erb-templates)
+  * [Using webhooks](#using-webhooks)
+  * [Developing your own plugin](#developing-your-own-plugin)
 * [Roadmap](#roadmap)
 * [Donations](#donations)
 
@@ -25,8 +30,8 @@ professional reporting functionality. And this is, where the ruby grafana report
 steps in.
 
 The key functionality of the reporter is to capture data and images from grafana
-dashboards and to use it in your custom reports to finally create reports in PDF,
-HTML, or any other format.
+dashboards and to use it in your custom templates to finally create reports in PDF
+(default), HTML, or any other format.
 
 By default (an extended version of) Asciidoctor is enabled as template language.
 
@@ -60,7 +65,7 @@ Database                  | Image rendering | Raw queries   | Composed queries
 ------------------------- | :-------------: | :-----------: | :------------:
 all SQL based datasources | supported       | supported     | supported
 Graphite                  | supported       | supported     | supported
-InfluxDB                  | supported       | supported     | not (yet) supported
+InfluxDB                  | supported       | supported     | supported
 Prometheus                | supported       | supported     | n/a in grafana
 other datasources         | supported       | not supported | not supported
 
@@ -73,6 +78,9 @@ specification to a raw query, which then in fact is sent to the database.
 
 ## Quick Start
 
+
+### Setup
+
 You don't have a grafana setup runnning already? No worries, just configure
 `https://play.grafana.org` in the configuration wizard and see the magic
 happen!
@@ -126,7 +134,7 @@ asciidoctor:
 ```
 * start/restart the asciidoctor docker container
 
-## Grafana integration
+### Grafana integration
 
 For using the reporter directly from grafana, you need to simply add a link to your
 grafana dashboard:
@@ -158,12 +166,14 @@ you should change the link of the `Demo Report` link to
 hitting the new link in the dashboard, grafana will add the selected template as
 a variable and forward it to the reporter.
 
-## Webservice overview
+## Advanced information
+
+### Webservice
 
 Running the reporter as a webservice provides the following URLs
 
     /overview - for all running or retained renderings
-    /render - for rendering a template, 'var-template' is the only mandatory GET parameter
+    /render - for rendering a template, 'var-template' is the only mandatory GET parameter, all parameters will be passed to the report templates as attributes
     /view_report - for viewing the status or receving the result of a specific rendering, is automatically called after a successfull /render call
     /cancel_report - for cancelling the rendering of a specific report, normally not called manually, but on user interaction in the /view_report or /overview URL
 
@@ -171,11 +181,135 @@ The main endpoint to call for report generation is configured in the previous ch
 
 However, if you would like to see, currently running report generations and previously generated reports, you may want to call the endpoint `/overview`.
 
+### Using ERB templates
+
+By default the configuration wizard will setup the reporter with the asciidoctor
+template language enabled. For several reasons, you may want to take advantage of
+the ruby included
+[ERB template language](https://docs.ruby-lang.org/en/master/ERB.html).
+
+Anyway you should consider, that ERB templates can include harmful code. So make
+sure, that you will only use ERB templates in a safe environment.
+
+To enable the ERB template language, you need to modify your configuration file
+in the section `grafana-reporter`:
+
+````
+grafana-reporter:
+  report-class: GrafanaReporter::ERB::Report
+````
+
+Restart the grafana reporter instance, if running as webservice. That's all.
+
+In ERB templates, you have access to the variables `report`, which is a reference
+to the currently executed
+[ERB Report object](https://rubydoc.info/gems/ruby-grafana-reporter/GrafanaReporter/ERB/Report)
+and `attributes`, which contains a hash
+of variables, which have been handed over to the report generations, e.g. from
+a webservice call.
+
+To test the configuration, you may want to run the configuration wizard again,
+which will create an ERB template for you.
+
+### Using webhooks
+
+Webhooks provide an easy way to get automatically informed about the progress
+of a report. The nice thing is, that this is completely independent from
+running the reporter as webservice, i.e. these callbacks are also called if you
+run the reporter standalone.
+
+To use webhooks, you have to specify, in which progress states of a report you
+are interested. Therefore you have to configure it in the `grafana-reporter`
+section of your configuration file, e.g.
+
+````
+grafana-reporter:
+  callbacks:
+    all:
+      - http://<<your_callback_url>>
+````
+
+Remember to restart the reporter, if it is running as a webservice.
+
+After having done so, your callback url will be called for each event with
+a JSON body including all necessary information of the report. For details see
+[callback](https://rubydoc.info/gems/ruby-grafana-reporter/GrafanaReporter/ReportWebhook#callback-instance_method).
+
+### Developing your own plugin
+
+The reporter is designed to allow easy integration of your own plugins,
+without having to modify the reporter base source on github (or anywhere
+else). This section shows how to implement and load a custom datasource.
+
+Implementing a custom datasource is needed, if you use a custom datasource
+grafana plugin, which is not yet supported by the reporter. In that case you
+can build your own custom datasource for the reporter and load it on demand
+with a command line parameter, without having to build your own fork of this
+project.
+
+This documentation will provide a simple, but mocked implementation of an
+imagined grafana datasource.
+
+First of all, let's create a new text file, e.g. `my_datasource.rb` with the
+following content:
+
+````
+class MyDatasource < ::Grafana::AbstractDatasource
+  def self.handles?(model)
+    tmp = new(model)
+    tmp.type == 'my_datasource'
+  end
+
+  def request(query_description)
+    # see https://rubydoc.info/gems/ruby-grafana-reporter/Grafana/AbstractDatasource#request-instance_method
+    # for detailed information of given parameters and expected return format
+
+    # TODO: call your datasource, e.g. via REST call
+    # TODO: return the value in the needed format
+  end
+
+  def raw_query_from_panel_model(panel_query_target)
+    # TODO: extract or build the query from the given grafana panel query target hash
+  end
+
+  def default_variable_format
+    # TODO, specify the default variable format
+    # see https://rubydoc.info/gems/ruby-grafana-reporter/Grafana/Variable#value_formatted-instance_method
+    # for detailed information.
+  end
+end
+````
+
+The only thing left to do now, is to make this datasource known to the
+reporter. This can be done with the `-r` command line flag, e.g.
+
+````
+ruby-grafana-reporter -r my_datasource.rb
+````
+
+The reporter implemented some magic, to automatically register datasource
+implementations on load, if they inherit from `::Grafana::AbstractDatasource`.
+This means, that you don't have to do anything else here.
+
+Now the reporter knows about your datasource implementation and will use it,
+if you request information from a panel, which is linked to the type
+`my_datasource` as specified in the `handles?` method above. If any errors
+occur during execution, the reporter will catch them and show them in the error
+log.
+
+Registering a custom ruby file is independent from running the reporter as a
+webservice or as a standalone executable. In any case the reporter will apply
+the file.
+
+Technically, loading your own plugin will call require for your ruby file,
+_after_ all reporter files have been loaded and _before_ the execution of the
+webservice or a rendering process starts.
+
 ## Roadmap
 
 This is just a collection of things, I am heading for in future, without a schedule.
 
-* Support all grafana datasources
+* Support grafana internal datasources
 * Solve code TODOs
 * Become [rubocop](https://rubocop.org/) ready
 
@@ -197,7 +331,6 @@ Inspired by [Izak Marai's grafana reporter](https://github.com/IzakMarais/report
 
 ## Donations
 
-If this project saves you as much time as I hope it does, and if you'd like to
-support my work, feel free donate. :)
+If you like this project and you would like to support my work, feel free to donate. :)
 
 [![paypal](https://www.paypalobjects.com/en_US/i/btn/btn_donateCC_LG.gif)](https://www.paypal.com/donate?hosted_button_id=35LH6JNLPHPHQ)

data/lib/VERSION.rb

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

data/lib/grafana/abstract_datasource.rb

@@ -42,12 +42,12 @@ module Grafana
       @model = model
     end
 
-    # @return [String] category of the datasource, e.g. `tsdb` or `sql`
+    # @return [String] category of the datasource, e.g. +tsdb+ or +sql+
     def category
       @model['meta']['category']
     end
 
-    # @return [String] type of the datasource, e.g. `mysql`
+    # @return [String] type of the datasource, e.g. +mysql+
     def type
       @model['type'] || @model['meta']['id']
     end
@@ -126,10 +126,16 @@ module Grafana
       while repeat && (repeat_count < 3)
         repeat = false
         repeat_count += 1
+
         variables.each do |name, variable|
+          # do not replace with non grafana variables
+          next unless name =~ /^var-/
+
           # only set ticks if value is string
           var_name = name.gsub(/^var-/, '')
-          res = res.gsub(/(?:\$\{#{var_name}(?::(?<format>\w+))?\}|\$#{var_name})/) do
+          next unless var_name =~ /^\w+$/
+
+          res = res.gsub(/(?:\$\{#{var_name}(?::(?<format>\w+))?\}|\$#{var_name}(?!\w))/) do
             format = default_variable_format
             if $LAST_MATCH_INFO
               format = $LAST_MATCH_INFO[:format] if $LAST_MATCH_INFO[:format]

data/lib/grafana/dashboard.rb

@@ -35,6 +35,11 @@ module Grafana
       @model['uid']
     end
 
+    # @return [String] dashboard title
+    def title
+      @model['title']
+    end
+
     # @return [Panel] panel for the specified ID
     def panel(id)
       panels = @panels.select { |item| item.field('id') == id.to_i }
@@ -53,7 +58,7 @@ module Grafana
       list = @model['templating']['list']
       return unless list.is_a? Array
 
-      list.each { |item| @variables << Variable.new(item) }
+      list.each { |item| @variables << Variable.new(item, self) }
     end
 
     # read panels

data/lib/grafana/errors.rb

@@ -37,9 +37,9 @@ module Grafana
 
   # Raised if a given datasource does not exist in a specific {Grafana} instance.
   class DatasourceDoesNotExistError < GrafanaError
-    # @param field [String] specifies, how the datasource has been searched, e.g. 'id' or 'name'
+    # @param field [String] specifies, how the datasource has been searched, e.g. +id+ or +name+
     # @param datasource_identifier [String] identifier of the datasource, which could not be found,
-    #   e.g. the specifiy id or name
+    #   e.g. the specified id or name
     def initialize(field, datasource_identifier)
       super("Datasource with #{field} '#{datasource_identifier}' does not exist.")
     end
@@ -53,7 +53,8 @@ module Grafana
   class ImageCouldNotBeRenderedError < GrafanaError
     def initialize(panel)
       super("The specified panel '#{panel.id}' from dashboard '#{panel.dashboard.id}' could not be "\
-        'rendered to an image.')
+        'rendered to an image. Check if rendering is possible manually by selecting "Share" and then '\
+        '"Direct link rendered image" from a panel\'s options menu.')
     end
   end
 
@@ -70,12 +71,4 @@ module Grafana
       super("The datasource query provided, does not look like a grafana datasource target (received: #{query}).")
     end
   end
-
-  # Raised if a datasource implementation cannot handle a query, which is composed
-  # in the grafana visual editor.
-  class ComposedQueryNotSupportedError < GrafanaError
-    def initialize(class_obj)
-      super("Composed queries are not yet supported for datasource '#{class_obj}'.")
-    end
-  end
 end

data/lib/grafana/grafana.rb

@@ -25,6 +25,30 @@ module Grafana
       initialize_datasources unless @base_uri.empty?
     end
 
+    # @return [Hash] Information about the current organization
+    def organization
+      return @organization if @organization
+
+      response = prepare_request({ relative_url: '/api/org/' }).execute
+      if response.is_a?(Net::HTTPOK)
+        @organization = JSON.parse(response.body)
+      end
+
+      @organization
+    end
+
+    # @return [String] grafana version
+    def version
+      return @version if @version
+
+      response = prepare_request({ relative_url: '/api/health' }).execute
+      if response.is_a?(Net::HTTPOK)
+        @version = JSON.parse(response.body)['version']
+      end
+
+      @version
+    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,
@@ -50,7 +74,7 @@ module Grafana
     # @return [Datasource] Datasource for the specified datasource name
     def datasource_by_name(datasource_name)
       datasource_name = 'default' if datasource_name.to_s.empty?
-      # TODO: add support for grafana builtin datasource types
+      # TODO: PRIO add support for grafana builtin datasource types
       return UnsupportedDatasource.new(nil) if datasource_name.to_s =~ /-- (?:Mixed|Dashboard|Grafana) --/
       raise DatasourceDoesNotExistError.new('name', datasource_name) unless @datasources[datasource_name]
 

data/lib/grafana/grafana_environment_datasource.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Grafana
+  # Implements a datasource to return environment related information about the grafana instance in a tabular format.
+  class GrafanaEnvironmentDatasource < ::Grafana::AbstractDatasource
+    # +:raw_query+ needs to contain a Hash with the following structure:
+    #
+    #   {
+    #     grafana:  {Grafana} object to query
+    #     mode:     'general' (default) or 'dashboards' for receiving different environment information
+    #   }
+    # @see AbstractDatasource#request
+    def request(query_description)
+      raise MissingSqlQueryError if query_description[:raw_query].nil?
+      raw_query = {mode: 'general'}.merge(query_description[:raw_query])
+
+      return dashboards_data(raw_query[:grafana]) if raw_query[:mode] == 'dashboards'
+
+      general_data(raw_query[:grafana])
+    end
+
+    # @see AbstractDatasource#default_variable_format
+    def default_variable_format
+      nil
+    end
+
+    # @see AbstractDatasource#name
+    def name
+      self.class.to_s
+    end
+
+    private
+
+    def general_data(grafana)
+      {
+        header: ['Version', 'Organization Name', 'Organization ID', 'Access permissions'],
+        content: [[grafana.version,
+                   grafana.organization['name'],
+                   grafana.organization['id'],
+                   grafana.test_connection]]
+      }
+    end
+
+    def dashboards_data(grafana)
+      content = []
+      grafana.dashboard_ids.each do |id|
+        content << [id, grafana.dashboard(id).title, grafana.dashboard(id).panels.length]
+      end
+
+      {
+        header: ['Dashboard ID', 'Dashboard Name', '# Panels'],
+        content: content
+      }
+    end
+  end
+end

data/lib/grafana/grafana_property_datasource.rb

@@ -16,6 +16,8 @@ module Grafana
       panel = query_description[:raw_query][:panel]
       property_name = query_description[:raw_query][:property_name]
 
+      return "Panel property '#{property_name}' does not exist for panel '#{panel.id}'" unless panel.field(property_name)
+
       {
         header: [query_description[:raw_query][:property_name]],
         content: [replace_variables(panel.field(property_name), query_description[:variables])]
@@ -24,7 +26,12 @@ module Grafana
 
     # @see AbstractDatasource#default_variable_format
     def default_variable_format
-        'glob'
+      'glob'
+    end
+
+    # @see AbstractDatasource#name
+    def name
+      self.class.to_s
     end
   end
 end

data/lib/grafana/image_rendering_datasource.rb

@@ -10,12 +10,16 @@ module Grafana
     #   }
     # @see AbstractDatasource#request
     def request(query_description)
+      panel = query_description[:raw_query][:panel]
+
       webrequest = query_description[:prepared_request]
-      webrequest.relative_url = query_description[:raw_query][:panel].render_url + url_params(query_description)
+      webrequest.relative_url = panel.render_url + url_params(query_description)
       webrequest.options.merge!({ accept: 'image/png' })
 
       result = webrequest.execute
 
+      raise ImageCouldNotBeRenderedError, panel if result.body.include?('<html')
+
       { header: ['image'], content: [result.body] }
     end
 

data/lib/grafana/influxdb_datasource.rb

@@ -15,7 +15,19 @@ module Grafana
     def request(query_description)
       raise MissingSqlQueryError if query_description[:raw_query].nil?
 
-      url = "/api/datasources/proxy/#{id}/query?db=#{@model['database']}&q=#{URI.encode(query_description[:raw_query])}&epoch=ms"
+      # replace variables
+      query = replace_variables(query_description[:raw_query], query_description[:variables])
+
+      # Unfortunately the grafana internal variables are not replaced in the grafana backend, but in the
+      # frontend, i.e. we have to replace them here manually
+      # replace $timeFilter variable
+      query = query.gsub(/\$timeFilter(?=\W|$)/, "time >= #{query_description[:from]}ms and time <= #{query_description[:to]}ms")
+
+      # replace grafana variables $__interval and $__interval_ms in query
+      query = query.gsub(/\$(?:__)?interval(?=\W|$)/, "#{((query_description[:to].to_i - query_description[:from].to_i) / 1000 / 1000).to_i}s")
+      query = query.gsub(/\$(?:__)?interval_ms(?=\W|$)/, "#{((query_description[:to].to_i - query_description[:from].to_i) / 1000).to_i}")
+
+      url = "/api/datasources/proxy/#{id}/query?db=#{@model['database']}&q=#{ERB::Util.url_encode(query)}&epoch=ms"
 
       webrequest = query_description[:prepared_request]
       webrequest.relative_url = url
@@ -29,8 +41,8 @@ module Grafana
     def raw_query_from_panel_model(panel_query_target)
       return panel_query_target['query'] if panel_query_target['rawQuery']
 
-      # TODO: support composed queries
-      raise ComposedQueryNotSupportedError, self
+      # build composed queries
+      build_select(panel_query_target['select']) + build_from(panel_query_target) + build_where(panel_query_target['tags']) + build_group_by(panel_query_target['groupBy'])
     end
 
     # @see AbstractDatasource#default_variable_format
@@ -40,10 +52,82 @@ module Grafana
 
     private
 
+    def build_group_by(stmt)
+      groups = []
+      fill = ""
+
+      stmt.each do |group|
+        case group['type']
+        when 'tag'
+          groups << "\"#{group['params'].first}\""
+
+        when 'fill'
+          fill = " fill(#{group['params'].first})"
+
+        else
+          groups << "#{group['type']}(#{group['params'].join(', ')})"
+
+        end
+      end
+
+      " GROUP BY #{groups.join(', ')}#{fill}"
+    end
+
+    def build_where(stmt)
+      custom_where = []
+
+      stmt.each do |where|
+        value = where['operator'] =~ /^[=!]~$/ ? where['value'] : "'#{where['value']}'"
+        custom_where << "\"#{where['key']}\" #{where['operator']} #{value}"
+      end
+
+      " WHERE #{"(#{custom_where.join(' AND ')}) AND " unless custom_where.empty?}$timeFilter"
+    end
+
+    def build_from(stmt)
+      " FROM \"#{"stmt['policy']." unless stmt['policy'] == 'default'}#{stmt['measurement']}\""
+    end
+
+    def build_select(stmt)
+      res = "SELECT"
+      parts = []
+
+      stmt.each do |value|
+        part = ""
+
+        value.each do |item|
+          case item['type']
+          when 'field'
+            # frame field parameter as string
+            part = "\"#{item['params'].first}\""
+
+          when 'alias'
+            # append AS with parameter as string
+            part = "#{part} AS \"#{item['params'].first}\""
+
+
+          when 'math'
+            # append parameter as raw value for calculation
+            part = "#{part} #{item['params'].first}"
+
+
+          else
+            # frame current part by brackets and call by item function including parameters
+            part = "#{item['type']}(#{part}#{", #{item['params'].join(', ')}" unless item['params'].empty?})"
+          end
+        end
+
+        parts << part
+      end
+
+      "#{res} #{parts.join(', ')}"
+    end
+
     # @see AbstractDatasource#preformat_response
     def preformat_response(response_body)
       # TODO: how to handle multiple query results?
       json = JSON.parse(response_body)['results'].first['series']
+      return {} if json.nil?
 
       header = ['time']
       content = {}

data/lib/grafana/panel.rb

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

data/lib/grafana/prometheus_datasource.rb

@@ -14,7 +14,11 @@ module Grafana
     def request(query_description)
       raise MissingSqlQueryError if query_description[:raw_query].nil?
 
-      url = "/api/datasources/proxy/#{id}/api/v1/query_range?"\
+      # TODO: properly allow endpoint to be set - also check raw_query method
+      end_point = @endpoint ? @endpoint : "query_range"
+
+      # TODO: set query option 'step' on request
+      url = "/api/datasources/proxy/#{id}/api/v1/#{end_point}?"\
             "start=#{query_description[:from]}&end=#{query_description[:to]}"\
             "&query=#{replace_variables(query_description[:raw_query], query_description[:variables])}"
 
@@ -28,6 +32,7 @@ module Grafana
 
     # @see AbstractDatasource#raw_query_from_panel_model
     def raw_query_from_panel_model(panel_query_target)
+      @endpoint = panel_query_target['format'] == 'time_series' && (panel_query_target['instant'] == false || !panel_query_target['instant']) ? 'query_range' : 'query'
       panel_query_target['expr']
     end
 
@@ -47,7 +52,11 @@ module Grafana
 
       # keep sorting, if json has only one target item, otherwise merge results and return
       # as a time sorted array
-      return { header: headers << json.first['metric']['mode'], content: json.first['values'] } if json.length == 1
+      # TODO properly set headlines
+      if json.length == 1
+        return { header: headers << json.first['metric'].to_s, content: [[json.first['value'][1], json.first['value'][0]]] } if json.first.has_key?('value') # this happens for the special case of calls to '/query' endpoint
+        return { header: headers << json.first['metric']['mode'], content: json.first['values'] }
+      end
 
       # TODO: show warning if results may be sorted different
       json.each_index do |i|

data/lib/grafana/sql_datasource.rb

@@ -19,7 +19,7 @@ module Grafana
         body: {
           from: query_description[:from],
           to: query_description[:to],
-          queries: [rawSql: prepare_sql(sql), datasourceId: id, format: 'table']
+          queries: [rawSql: sql, datasourceId: id, format: 'table']
         }.to_json,
         request: Net::HTTP::Post
       }
@@ -49,6 +49,8 @@ module Grafana
     def preformat_response(response_body)
       results = {}
       results.default = []
+      results[:header] = []
+      results[:content] = []
 
       JSON.parse(response_body)['results'].each_value do |query_result|
         if query_result.key?('error')
@@ -66,13 +68,5 @@ module Grafana
 
       results
     end
-
-    def prepare_sql(sql)
-      # remove comments in query
-      sql.gsub!(/--[^\r\n]*(?:[\r\n]+|$)/, ' ')
-      sql.gsub!(/\r\n/, ' ')
-      sql.gsub!(/\n/, ' ')
-      sql
-    end
   end
 end