sensu-extensions-influxdb2 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0b0f5ae119ad47adabd692247f89da5e49cb47de
+  data.tar.gz: 0ae41118ccc5cc0e25601dcb74100f962bf00e3b
+SHA512:
+  metadata.gz: 467a5cdf430eeace8fa6fd22031a6298414bccc34e4060d5dca52f300b9a2132f2d6d95754d0a8623b0e52ec3acc953261772a6862b70123bb7b62cab8efc518
+  data.tar.gz: a9f5a6f2640344f25b1ad23e7a7a34e90405fa5c5241992fc50be12520988f584b613dbdd05e4c55a5d02515190b3ca5cf21797926c2a6cf48ee89867932fe31

data/LICENSE

@@ -0,0 +1,15 @@
+Copyright 2014 John E. Vincent and contributors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+

data/README.md

@@ -0,0 +1,258 @@
+__NOTE:__ running `sensu-install -e sensu-extensions-influxdb` will __NOT__ install this extension, as a project with the same name already exists on Rubygems.org. Before reporting any issues here, make sure you are using this version of the extension. (_hint:_ check the version number on the logs)
+
+# Requirements
+
+This extension uses InfluxDB [Line Protocol](https://influxdb.com/docs/v0.9/write_protocols/line.html) over HTTP to send metrics.
+
+Since Sensu already uses [eventmachine](https://github.com/eventmachine/eventmachine), you just have to ensure that em-http-request gem is present inside Sensu's embedded Ruby :
+* `em-http-request` ruby gem
+
+By default, this extension uses in memory metrics caching : it makes InfluxDB writes batched.
+This cache is flushed every __500 items__ or __6 seconds__ (this values can be changed in conf).
+
+## Caveat
+* SSL/TLS connection to InfluxDB is still broken in Sensu `0.20.6`. We're waiting for a Ruby / EM upgrade in Sensu project :
+    * https://github.com/sensu/sensu/issues/1084
+
+# Usage
+The configuration options are pretty straight forward.
+
+Metrics are inserted into the database using the check's key name as _measurement_ name. So if you're using the `sensu-plugins-load-checks` community plugin :
+```
+my-host-01.load_avg.one 0.02 1444824197
+my-host-01.load_avg.five 0.04 1444824197
+my-host-01.load_avg.fifteen 0.09 1444824197
+```
+In this example, you'll have 3 differents _measurements_ in your database :
+```
+> show measurements
+name: measurements
+------------------
+name
+my-host-01.load_avg.fifteen
+my-host-01.load_avg.five
+my-host-01.load_avg.one
+```
+
+```
+> select * from "my-host-01.load_avg.one";
+name: my-host-01.load_avg.one
+------------------
+time                  host        value  duration
+2015-10-14T13:53:22Z  my-host-01  0.34   0.399
+2015-10-14T13:53:32Z  my-host-01  0.29   0.419
+2015-10-14T13:53:42Z  my-host-01  0.39   0.392
+2015-10-14T13:53:52Z  my-host-01  0.41   0.398
+[...]
+```
+
+Additionally a `duration` value will be present based on the time it took the check to run (this is gleaned from the sensu event data).
+
+The name of the _measurement_ is based on the value of `strip_metric` and/or a template, as described below.
+The name of the key ```host``` is grabbed from sensu event client name.
+
+## Extension not a handler
+Note that the first push of this was a handler that could be called via `pipe`. This is now an actual extension that's more performant since it's actually in the sensu-server runtime. Additionally it's now using batch submission to InfluxDB by writing all the points for a given series at once.
+
+To [load the extension](https://sensuapp.org/docs/latest/reference/extensions.html), you will need to install the gem into the sensu ruby, and then add the following config file
+```json
+{
+  "extensions": {
+    "influxdb": {
+      "gem": "sensu-extensions-influxdb",
+    },
+    "history": {
+      "gem": "sensu-extensions-history",
+    }
+  }
+}
+```
+
+**NOTE**: Even though this gem is called `sensu-extensions-influxdb`, the way sensu loads the extension is by parsing the name of the gem, and loading the library. This is why we have to specify `sensu-extensions-history`, even though that gem doesn't exist.
+
+Create a set to wrap this extension into a callable handler. In this example, we created a ```metrics``` handler wrapping a debug output and this Influx extension :
+
+_/etc/sensu/conf.d/handlers/metrics.json_ :
+```json
+{
+  "handlers": {
+    "metrics": {
+      "type": "set",
+      "handlers": [ "debug", "influxdb"]
+      }
+    }
+  }
+}
+```
+
+_Note :_ Since Sensu 0.17.1 you can also use extension name directly :
+```
+Check definitions can now specify a Sensu check extension to run,
+"extension", instead of a command.
+```
+
+## Handler config
+
+`/etc/sensu/conf.d/influxdb.json`
+```json
+{
+  "influxdb": {
+    "database": "stats",
+    "host": "localhost",
+    "port": "8086",
+    "username": "stats",
+    "password": "stats",
+    "use_ssl": false,
+    "strip_metric": "host",
+    "tags": {
+      "region": "my-dc-01",
+      "stage": "prod"
+    },
+    "templates": [
+      {"^sensu\\.checks\\..*":"source.measurement.field*"},
+      {".*\\.cgroup\\..*": "host.path.component"}
+    ]
+  }
+}
+```
+
+### Config attributes
+
+* `host`, `port`, `username`, `password` and `database` are pretty straight forward. If `use_ssl` is set to true, the connection to the influxdb server will be made using https instead of http.
+
+* `use_basic_auth` if your InfluxDB is behind a proxy that requires authentication you can set this to `true`, in that case you also have to define `basic_user` and `basic_pass`.
+
+* `filters` allow's you to "find and replace" words/patterns in the key, it's a Hash where the key is a regex pattern and the value is a string that should replace it. (these are passed directly to the gsub method). Filters are applyed before any other transformations like templates.
+
+* `templates` like with the InfluxDB Graphite plugin, you can specify patterns and formats, if the metric name matches the pattern, the template will be applied. Templates can be defined per check, in the check configuration, or globaly in the handler's configuration. Parts of the metric name will be converted into tags, reducing the measurement name in InfluxDB whilst keeping all the information as tags or fields.
+You can specifty multiple templates, if your metric matches more than one the first one will be used.
+For example, if you have a metric named:
+```
+  ip-10-0-1-32.host_stats.load_avg 3
+```
+You can set a template like:
+```json
+  "templates":{
+    ".*\\.host_stats\\..*": "host.type"
+  }
+```
+And as a result the following will be sent to InfluxDB:
+```
+  load_avg,host=ip-10-0-1-32,type=host_stats value=3
+```
+You can also use three special keywords in your templates, `void`, `measurement` and `field` and these can be used with a `*` at the end.
+Example, considereing the following metrics:
+```
+  ip-10-0-1-32.host_stats.load_avg.one 3
+  ip-10-0-1-32.host_stats.load_avg.five 9
+  ip-10-0-1-32.host_stats.load_avg.fifteen 13
+```
+You could create a template like this:
+```json
+  "templates":{
+    ".*\\.host_stats\\..*": "host.measurement.field*"
+  }
+```
+And you would get:
+```
+  host_stats,host=ip-10-0-1-32 load_avg.one=3
+  host_stats,host=ip-10-0-1-32 load_avg.five=9
+  host_stats,host=ip-10-0-1-32 load_avg.fifteen=13
+```
+Or, a template like this:
+```json
+  "templates":{
+    ".*\\.host_stats\\..*": "host.measurement.field.aggregation"
+  }
+```
+Would get you:
+```
+  host_stats,host=ip-10-0-1-32,aggregation=one load_avg=3
+  host_stats,host=ip-10-0-1-32,aggregation=five load_avg=9
+  host_stats,host=ip-10-0-1-32,aggregation=fifteen load_avg=13
+```
+the `void` keyword will make the handler ignore that part of the metric name.
+
+* `tags` hash is also pretty straight forward. Just list here in a flat-hash design as many influxdb tags you wish to be added in your measures. This can also be set both in the handler configuration or as part of the check configuration.
+
+* `strip_metric` however might not be. This is used to "clean up" the data sent to influxdb. Normally everything sent to handlers is akin to the `graphite`/`stats` style:
+```
+  something.host.metrictype.foo.bar
+```
+or
+```
+  host.stats.something.foo.bar
+```
+
+Really the pattern is irrelevant. People have different tastes. Adding much of that data to the column name in InfluxDB is rather silly so `strip_metric` provides you with a chance to add a value that strips off everything up to (and including that value). This allows you to continue sending to graphite or statsd or whatever and still use this handler.
+
+Using the examples above, if you set the `strip_metric` to `host`, then the measurement in InfluxDB would be called `metrictype.foo.bar` or `stats.something.foo.bar`. If you set the value to `foo` then the measurement would simply be called `foo`
+
+Note that :
+* `strip_metric` isn't required.
+* `strip_metric` can be set either in the handler configuration or as part of the check configuration, check configuration takes precedence.
+* you can cleanup an arbitrary string from your keyname or use `host` as special value to cleanup the sensu event client name from your key.
+
+#### Other attributes
+
+* `time_precision` : global checks time precision (default is `'s'`)
+* `buffer_max_size` : buffer size limit before flush - This is the amount of points in the InfluxDB batch - (default is `500`)
+* `buffer_max_age` : buffer maximum age - Flush will be forced after this amount of time - (default is `6` seconds)
+* `Proxy mode` : If the extension is configured to be in proxy mode, it will skip the transformation step and assume that the data is valid [line protocol](https://docs.influxdata.com/influxdb/latest/write_protocols/line_protocol_reference). It will not take into account any tags defined in the sensu-configuration.
+
+## Check options
+
+In the check config, an optional `influxdb` section can be added, containing a `database` option and `tags`.
+You can also set `proxy_mode` in this section on the checks to override the default configuration set on the handler. This way checks that use the InfluxDB line protocol can coexsist with checks that use the Graphite format and use the same handler.
+As mentioned above you can also specify `strip_metric`, `templates` and `filters`,  in the check configuration.
+If specified, this overrides the default `database` and `strip_metric` options in the handler config and adds (or overrides) influxdb tags and templates.
+
+This allows events to be written to different influxdb databases and modify key indexes on a check-by-check basis.
+
+You can also specify the time precision of your check script in the check config with the `time_precision` attribute.
+
+### Example check config
+
+`/etc/sensu/conf.d/checks/metrics-load.json`
+```json
+{
+  "checks": {
+    "metrics-load": {
+      "type": "metric",
+      "command": "metrics-load.rb",
+      "standalone": true,
+      "handlers": [
+        "metrics"
+      ],
+      "interval": 60,
+      "time_precision": "s",
+      "influxdb": {
+        "database": "custom-db",
+        "tags": {
+           "stage": "prod",
+           "region": "eu-west-1"
+        },
+        "templates": {
+          "^load_avg\\..*": "measurement.field"
+        }
+      }
+    }
+  }
+}
+```
+
+_Result_ :
+```
+load_avg,stage:prod,region:eu-west-1,host:iprint-test-sa-01.photobox.com one=1.04,duration=0.402  1444816792147
+load_avg,stage:prod,region:eu-west-1,host:iprint-test-sa-01.photobox.com five=0.86,duration=0.398 1444816792147
+load_avg,stage:prod,region:eu-west-1,host:iprint-test-sa-01.photobox.com fifteen=0.84,duration=0.375 1444816792147
+
+ * will be sent to -> http://my-influx09.company.com:8086/db/custom-db/series?time_precision=s&u=sensu&p=sensu
+```
+
+Without the tags and templates you would get:
+```
+load_avg.one,host:iprint-test-sa-01.photobox.com value=1.04,duration=0.402  1444816792147
+load_avg.five,host:iprint-test-sa-01.photobox.com value=0.86,duration=0.398 1444816792147
+load_avg.fifteen,host:iprint-test-sa-01.photobox.com value=0.84,duration=0.375 1444816792147
+```

data/lib/sensu/extensions/history.rb

@@ -0,0 +1,85 @@
+require 'rubygems' if RUBY_VERSION < '1.9.0'
+require 'em-http-request'
+require 'eventmachine'
+require 'multi_json'
+require 'sensu/extension'
+require 'sensu/extensions/influxdb2/influx_relay'
+
+module Sensu
+  module Extension
+    class History < Bridge
+      def name
+        definition[:name]
+      end
+
+      def definition
+        {
+          type: 'extension',
+          name: 'history'
+        }
+      end
+
+      def description
+        'Sends check result data to influxdb'
+      end
+
+      def post_init
+        @influx_conf = parse_settings
+        logger.info("InfluxDB history extension initialiazed using #{@influx_conf['base_url']} - Defaults : db=#{@influx_conf['database']} precision=#{@influx_conf['time_precision']}")
+
+        @relay = InfluxRelay.new
+        @relay.init(@influx_conf)
+
+        logger.info("History write buffer initiliazed : buffer flushed every #{@influx_conf['buffer_max_size']} points OR every #{@influx_conf['buffer_max_age']} seconds) ")
+      end
+
+      def run(event_data)
+        if event_data[:check][:type] != 'standard' && event_data[:check][:type] != 'check'
+          yield '', 0
+          return
+        end
+
+        host = event_data[:client][:name]
+        metric = event_data[:check][:name]
+        timestamp = event_data[:check][:executed]
+        value = event_data[:check][:status]
+        output = "#{@influx_conf['scheme']}.checks.#{metric},type=history,host=#{host} value=#{value} #{timestamp}"
+
+        @relay.push(@influx_conf['database'], @influx_conf['time_precision'], output)
+        yield output, 0
+      end
+
+      def stop
+        logger.info('Flushing history buffer before exiting')
+        @relay.flush_buffer
+        true
+      end
+
+      private
+
+      def parse_settings
+        settings = @settings['influxdb']
+        if @settings.include?('history')
+          settings.merge!(@settings['history'])
+        end
+        # default values
+        settings['tags'] ||= {}
+        settings['use_ssl'] ||= false
+        settings['time_precision'] ||= 's'
+        settings['protocol'] = settings['use_ssl'] ? 'https' : 'http'
+        settings['buffer_max_size'] ||= 500
+        settings['buffer_max_age'] ||= 6 # seconds
+        settings['port'] ||= 8086
+        settings['scheme'] ||= 'sensu'
+        settings['base_url'] = "#{settings['protocol']}://#{settings['host']}:#{settings['port']}"
+        return settings
+      rescue => e
+        logger.error("Failed to parse History settings #{e}")
+      end
+
+      def logger
+        Sensu::Logger.get
+      end
+    end
+  end
+end

data/lib/sensu/extensions/influxdb2.rb

@@ -0,0 +1,228 @@
+require 'rubygems' if RUBY_VERSION < '1.9.0'
+require 'em-http-request'
+require 'eventmachine'
+require 'multi_json'
+require 'sensu/extension'
+require 'sensu/extensions/influxdb2/influx_relay'
+
+require 'sensu/extensions/influxdb2/version'
+
+module Sensu
+  module Extension
+    class InfluxDB2 < Handler
+      def name
+        definition[:name]
+      end
+
+      def definition
+        {
+          type: 'extension',
+          name: 'influxdb'
+        }
+      end
+
+      def description
+        'Outputs metrics to InfluxDB'
+      end
+
+      def post_init
+        @influx_conf = parse_settings
+        logger.info("InfluxDB extension initialiazed using #{@influx_conf['base_url']} - Defaults : db=#{@influx_conf['database']} precision=#{@influx_conf['time_precision']}")
+
+        @relay = InfluxRelay.new
+        @relay.init(@influx_conf)
+
+        logger.info("InfluxDB write buffer initiliazed : buffer flushed every #{@influx_conf['buffer_max_size']} points OR every #{@influx_conf['buffer_max_age']} seconds) ")
+      end
+
+      def run(event_data)
+        event = parse_event(event_data)
+        if event[:check][:status] != 0
+          logger.error('Check status is not OK!')
+          yield 'error', event[:check][:status]
+          return
+        end
+        data = {}
+        # init event and check data
+        data[:client] = event[:client][:name]
+        # This will merge : default conf tags < check embedded tags < sensu client/host tag
+        data[:tags] = @influx_conf['tags'].merge(event[:check][:influxdb][:tags]).merge('host' => data[:client])
+        client_tags = event[:client][:tags] || {}
+        check_tags = event[:check][:tags] || {}
+        data[:tags].merge!(client_tags.merge(check_tags))
+        # This will merge : check embedded templaes < default conf templates (check embedded templates will take precedence)
+        data[:templates] = event[:check][:influxdb][:templates] + @influx_conf['templates']
+        data[:filters] = event[:check][:influxdb][:filters].merge(@influx_conf['filters'])
+        event[:check][:influxdb][:database] ||= @influx_conf['database']
+        event[:check][:time_precision] ||= @influx_conf['time_precision']
+        event[:check][:influxdb][:strip_metric] ||= @influx_conf['strip_metric']
+        data[:strip_metric] = event[:check][:influxdb][:strip_metric]
+        data[:duration] = event[:check][:duration]
+        event[:check][:output].split(/\r\n|\n/).each do |line|
+          unless @influx_conf['proxy_mode'] || event[:check][:influxdb][:proxy_mode]
+            data[:line] = line
+            line = parse_line(data)
+          end
+          @relay.push(event[:check][:influxdb][:database], event[:check][:time_precision], line)
+        end
+        yield 'ok', 0
+      end
+
+      def stop
+        logger.info('Flushing InfluxDB buffer before exiting')
+        @relay.flush_buffer
+        true
+      end
+
+      private
+
+      def parse_event(event_data)
+        event = MultiJson.load(event_data, symbolize_keys: true)
+
+        # default values
+        # n, u, ms, s, m, and h (default community plugins use standard epoch date)
+        event[:check][:time_precision] ||= nil
+        event[:check][:influxdb] ||= {}
+        event[:check][:influxdb][:tags] ||= {}
+        event[:check][:influxdb][:templates] ||= {}
+        event[:check][:influxdb][:templates] = h2a(event[:check][:influxdb][:templates])
+        event[:check][:influxdb][:filters] ||= {}
+        event[:check][:influxdb][:database] ||= nil
+        event[:check][:influxdb][:proxy_mode] ||= false
+        return event
+      rescue => e
+        logger.error("Failed to parse event data: #{e}")
+      end
+
+      def h2a(h)
+        return h unless h.is_a?(Hash)
+        x = []
+        h.each do |k, v|
+          x << { k => v }
+        end
+        x
+      end
+
+      def parse_settings
+        settings = @settings['influxdb']
+
+        # default values
+        settings['tags'] ||= {}
+        settings['templates'] ||= {}
+        settings['templates'] = h2a(settings['templates'])
+        settings['filters'] ||= {}
+        settings['strip_metric'] ||= nil
+        settings['use_ssl'] ||= false
+        settings['use_basic_auth'] ||= false
+        settings['proxy_mode'] ||= false
+        settings['debug_relay'] ||= false
+        settings['time_precision'] ||= 's'
+        settings['protocol'] = settings['use_ssl'] ? 'https' : 'http'
+        settings['buffer_max_size'] ||= 500
+        settings['buffer_max_age'] ||= 6 # seconds
+        settings['port'] ||= 8086
+        settings['base_url'] = "#{settings['protocol']}://#{settings['host']}:#{settings['port']}"
+        return settings
+      rescue => e
+        logger.error("Failed to parse InfluxDB settings #{e}")
+      end
+
+      def strip_key(key, strip_metric, hostname)
+        return key if strip_metric.to_s.empty?
+        if strip_metric == 'host'
+          slice_host(key, hostname)
+        elsif strip_metric
+          key.gsub(/^.*#{strip_metric}\.(.*$)/, '\1')
+        end
+      end
+
+      def slice_host(slice, prefix)
+        prefix.chars.zip(slice.chars).each do |char1, char2|
+          break if char1 != char2
+          slice.slice!(char1)
+        end
+        slice.slice!('.') if slice.chars.first == '.'
+        slice
+      end
+
+      def get_name(arr1, arr2, pattern)
+        pos = arr1.index { |s| s =~ /#{pattern}/ }
+        if arr1[pos] =~ /\*$/
+          arr2[pos...arr2.length].join('.')
+        elsif arr1[pos] =~ /\d$/
+          arr2[pos...arr1[pos].scan(/\d/).join.to_i + pos].join('.')
+        else
+          arr2[pos]
+        end
+      end
+
+      def sanitize(str)
+        str.gsub(',', '\,').gsub(/\s/, '\ ').gsub('"', '\"').gsub('\\') { '\\\\' }.delete('*').squeeze('.')
+      end
+
+      def parse_line(event)
+        field_name = 'value'
+        key, value, time = event[:line].split(/\s+/)
+
+        # Apply filters
+        event[:filters].each do |pattern, replacement|
+          key.gsub!(/#{pattern}/, replacement)
+        end
+
+        # Strip metric name
+        key = strip_key(key, event[:strip_metric], event[:client]) unless event[:strip_metric].nil?
+
+        # Sanitize key name
+        key = sanitize(key)
+
+        tags = {}.merge(event[:tags])
+        event[:templates].each do |k, v|
+          pattern = k
+          template = v
+          if k.is_a?(Hash) # Array of Hashes
+            k = k.to_a.flatten
+            pattern = k[0]
+            template = k[1]
+          end
+          next unless key =~ /#{pattern}/
+          template = template.split('.')
+          key = key.split('.')
+          key_tags = if template.last =~ /\*$/ && !(template.last =~ /field/) && !(template.last =~ /measurement/)
+                       key[0...template.length - 1] << key[template.length - 1...key.length].join('.')
+                     else
+                       key[0...template.length]
+                     end
+
+          field_name = get_name(template, key, 'field') if template.index { |s| s =~ /field/ }
+
+          key = if template.index { |s| s =~ /measurement/ }
+                  get_name(template, key, 'measurement')
+                else
+                  key[key_tags.length...key.length]
+                end
+
+          template.each_with_index do |tag, i|
+            unless i >= key_tags.length || tag =~ /field/ || tag =~ /measurement/ || tag == 'void' || tag == 'null' || tag == 'nil'
+              tags.merge!(sanitize(tag) => key_tags[i])
+            end
+          end
+          break
+        end
+
+        # Append tags to measurement
+        tags.each do |tag, val|
+          next if val.to_s.empty? # skips tags without values
+          key += ",#{sanitize(tag.to_s)}=#{sanitize(val.to_s)}"
+        end
+
+        values = "#{field_name}=#{value.to_f}"
+        values += ",duration=#{event[:duration].to_f}" if event[:duration]
+        [key, values, time.to_i].join(' ')
+      end
+
+      def logger
+        Sensu::Logger.get
+      end
+    end
+  end
+end

data/lib/sensu/extensions/influxdb2/influx_relay.rb

@@ -0,0 +1,77 @@
+require 'rubygems' if RUBY_VERSION < '1.9.0'
+require 'em-http-request'
+require 'eventmachine'
+
+module Sensu
+  module Extension
+    class InfluxRelay
+      def init(config)
+        @influx_conf = config
+        @buffer = {}
+        @flush_timer = EventMachine::PeriodicTimer.new(@influx_conf['buffer_max_age'].to_i) do
+          unless buffer_size.zero?
+            flush_buffer
+          end
+        end
+      end
+
+      def flush_buffer
+        logger.info('Flushing Buffer')
+        @buffer.each do |db, tp|
+          tp.each do |p, points|
+            influxdb = EventMachine::HttpRequest.new("#{@influx_conf['base_url']}/write")
+            post_data = {}
+            post_data[:query] = { 'db' => db, 'precision' => p, 'u' => @influx_conf['username'], 'p' => @influx_conf['password'] }
+            post_data[:body] = points.join(" \n")
+            if @influx_conf['use_basic_auth']
+              post_data[:head] = { 'authorization' => [@influx_conf['basic_user'], @influx_conf['basic_pass']] }
+            end
+            result = influxdb.post(post_data)
+            next if @influx_conf.key?(db) && @influx_conf['debug_relay'] == false # this is to avoid the performance impact of checking the response everytime
+            result.callback do
+              if result.response =~ /.*error.*/
+                logger.error("InfluxDB response: #{result.response}")
+                if result.response =~ /.*database not found.*/
+                  post_data = {}
+                  post_data[:body] = ''
+                  post_data[:query] = {
+                    'db' => db,
+                    'precision' => p,
+                    'u' => @influx_conf['username'],
+                    'p' => @influx_conf['password'],
+                    'q' => "create database #{db}"
+                  }
+                  if @influx_conf['use_basic_auth']
+                    post_data[:head] = { 'authorization' => [@influx_conf['basic_user'], @influx_conf['basic_pass']] }
+                  end
+                  EventMachine::HttpRequest.new("#{@influx_conf['base_url']}/query").post(post_data)
+                  @influx_conf[db] = true
+                end
+              else
+                logger.debug("Written: #{post_data[:body]}")
+                @influx_conf[db] = true
+              end
+            end
+          end
+          @buffer[db] = {}
+        end
+      end
+
+      def buffer_size
+        @buffer.map { |_db, tp| tp.map { |_p, points| points.length }.inject(:+) }.inject(:+) || 0
+      end
+
+      def push(database, time_precision, data)
+        @buffer[database] ||= {}
+        @buffer[database][time_precision] ||= []
+
+        @buffer[database][time_precision].push(data)
+        flush_buffer if buffer_size >= @influx_conf['buffer_max_size']
+      end
+
+      def logger
+        Sensu::Logger.get
+      end
+    end
+  end
+end

data/lib/sensu/extensions/influxdb2/version.rb

@@ -0,0 +1,10 @@
+
+module SensuExtensionsInfluxDB2
+  module Version
+    MAJOR = 0
+    MINOR = 0
+    PATCH = 2
+
+    VER_STRING = [MAJOR, MINOR, PATCH].compact.join('.')
+  end
+end

metadata

@@ -0,0 +1,219 @@
+--- !ruby/object:Gem::Specification
+name: sensu-extensions-influxdb2
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Critical Media
+- Sensu-Plugins and contributors
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-11-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sensu-extension
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: em-http-request
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.40.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.40.0
+- !ruby/object:Gem::Dependency
+  name: sensu-logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sensu-settings
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: github-markup
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+description: Extension to get metrics and checks results into InfluxDB
+email:
+- "<steve.viola@criticalmedia.com>"
+- "<sensu-users@googlegroups.com>"
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/sensu/extensions/history.rb
+- lib/sensu/extensions/influxdb2.rb
+- lib/sensu/extensions/influxdb2/influx_relay.rb
+- lib/sensu/extensions/influxdb2/version.rb
+homepage: https://github.com/criticalmedia/sensu-extensions-influxdb
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2.1
+signing_key: 
+specification_version: 4
+summary: Extension to get metrics and checks results into InfluxDB
+test_files: []