influxdb 0.2.6 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 122c637f20d98ea27ff046720c702d3bf18b8ff5
-  data.tar.gz: bc260fe3b1a9bdaf45e517567f7d1a968a464e63
+  metadata.gz: a21a286129826d9f88c4ca4e8dc87676b6f017a2
+  data.tar.gz: e42cd53060f55865f25b480fd2894a5a375d9961
 SHA512:
-  metadata.gz: ef62b971bf3165b918c96699cb3493193d9883b5378f773b8b1ae9204ac5cf6173ef23dcb27b554d10fc61b069a743205fc930684103a9d0daf19e773fa14bd5
-  data.tar.gz: 70094c9a541fd931329bf6240cf809333a2ce4a7b58f6052bb36bf29bbf5a2b89f10e5d90086cb6b8d743517cc12ae23907e5eccdecfd0e91057294a70cce8df
+  metadata.gz: 405f425003836d44d9d7123d6bfd7b24be8f2955737e2922b40743e86cd5434bc7443f7b4f23c4ad6346ed17d27b41836b9eaba92ff0b70d301469617e033b28
+  data.tar.gz: 2fe79f2e54e16890cf5cfc6f50cbe45d282cf2f3a241305b6b925542b4f5e2603a60c8e0559d4402647ed586e972a46fd30ebae14368c7bd14f264bb83ea1a52

data/.rubocop.yml

@@ -1,8 +1,8 @@
 AllCops:
-  # Include gemspec and Rakefile
   Include:
+    - 'Rakefile'
+    - '*.gemspec'
     - 'lib/**/*.rb'
-    - 'lib/**/*.rake'
     - 'spec/**/*.rb'
   Exclude:
     - 'bin/**/*'

data/.travis.yml

@@ -1,16 +1,31 @@
+sudo: required
+dist: trusty
 language: ruby
 before_install:
   - gem update bundler
 rvm:
   - 2.0.0
-  - 2.1.0
-  - 2.2.0
+  - 2.1.10
+  - 2.2.4
   - 2.3.0
   - ruby-head
-  - jruby-20mode
-  - jruby-21mode
-  - jruby-head
+env:
+  - TEST_TASK=spec
 matrix:
   allow_failures:
     - rvm: jruby-head
     - rvm: ruby-head
+    - rvm: jruby-9.0.5.0
+  include:
+    - rvm: 2.3.0
+      env: TEST_TASK=rubocop
+    - rvm: jruby-9.0.5.0
+      env: JRUBY_OPTS='-J-Xmx256M'
+    - rvm: jruby-head
+      env: JRUBY_OPTS='-J-Xmx256M'
+  fail_fast: true
+addons:
+  apt:
+    packages:
+      - libgmp-dev
+script: bundle exec rake $TEST_TASK

data/CHANGELOG.md

@@ -0,0 +1,58 @@
+# Changelog
+
+For the full commit log, [see here](https://github.com/influxdata/influxdb-ruby/commits/master).
+
+## v0.3.0, released 2016-04-24
+
+- Write queries are now checked against 204 No Content responses, in accordance with the official documentation (#128).
+- Async options are now configurabe (#107).
+
+## v0.2.6, released 2016-04-14
+
+- Empty tag keys/values are now omitted (#124).
+
+## v0.2.5, released 2016-04-14
+
+- Async writer now behaves when stopping the client (#73).
+- Update development dependencies and started enforcing Rubocop styles.
+
+## v0.2.4, released 2016-04-12
+
+- Added `InfluxDB::Client#version`, returning the server version (#117).
+- Fixed escaping issues (#119, #121, #135).
+- Interger values are now written as Integer, not as Float value (#131).
+- Return all result series when querying multiple selects (#134).
+- Made host cycling thread safe (#136).
+
+## v0.2.3, released 2015-10-27
+
+- Added `epoch` option to client constructor and write methods (#104).
+- Added `#list_user_grants` (#111), `#grant_user_admin_privileges` (#112) and `#alter_retention_policy` (#114) methods.
+
+## v0.2.2, released 2015-07-29
+
+- Fixed issues with Async client (#101)
+- Avoid usage of `gsub!` (#102)
+
+## v0.2.1, released 2015-07-25
+
+- Fix double quote tags escaping (#98)
+
+## v0.2.0, released 2015-07-20
+
+- Large library refactoring (#88, #90)
+  - Extract config from client
+  - Extract HTTP functionality to separate module
+  - Extract InfluxDB management functions to separate modules
+  - Add writer concept
+  - Refactor specs (add cases)
+  - Add 'denormalize' option to config
+  - Recognize SeriesNotFound error
+  - Update README
+  - Add Rubocop config
+  - Break support for Ruby < 2
+- Added support for InfluxDB 0.9+ (#92)
+
+## v0.1.9, released 2015-07-04
+
+- last version to support InfluxDB 0.8.x

data/README.md

@@ -345,7 +345,7 @@ name     = 'foobar'
 influxdb = InfluxDB::Client.new database,
                                 username: username,
                                 password: password,
-                                async: true
+                                async:    true
 
 data = {
   values: { value: 0 },
@@ -356,6 +356,28 @@ data = {
 influxdb.write_point(name, data)
 ```
 
+Using `async: true` is a shortcut for the following:
+
+``` ruby
+async_options = {
+  # number of points to write to the server at once
+  max_post_points:    1000,
+  # queue capacity
+  max_queue_size:     10_000,
+  # number of threads
+  num_worker_threads: 3,
+  # max. time (in seconds) a thread sleeps before
+  # checking if there are new jobs in the queue
+  sleep_interval:     5
+}
+
+influxdb = InfluxDB::Client.new database,
+                                username: username,
+                                password: password,
+                                async:    async_options
+```
+
+
 Write data via UDP (note that a retention policy cannot be specified for UDP writes):
 
 ``` ruby

data/Rakefile

@@ -1,4 +1,7 @@
 require "bundler/gem_tasks"
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
 
 targeted_files = ARGV.drop(1)
 file_pattern = targeted_files.empty? ? 'spec/**/*_spec.rb' : targeted_files

data/influxdb.gemspec

@@ -3,13 +3,14 @@ lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'influxdb/version'
 
+# rubocop:disable Style/SpecialGlobalVars
 Gem::Specification.new do |spec|
   spec.name          = "influxdb"
   spec.version       = InfluxDB::VERSION
   spec.authors       = ["Todd Persen"]
   spec.email         = ["influxdb@googlegroups.com"]
-  spec.description   = %q{This is the official Ruby library for InfluxDB.}
-  spec.summary       = %q{Ruby library for InfluxDB.}
+  spec.description   = "This is the official Ruby library for InfluxDB."
+  spec.summary       = "Ruby library for InfluxDB."
   spec.homepage      = "http://influxdb.org"
   spec.license       = "MIT"
 
@@ -19,13 +20,10 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_runtime_dependency "json"
+  spec.add_runtime_dependency "cause" if RUBY_VERSION < '2.1'
 
-  if RUBY_VERSION < '2.1'
-    spec.add_runtime_dependency "cause"
-  end
-
-  spec.add_development_dependency "bundler",  "~> 1.3"
   spec.add_development_dependency "rake"
+  spec.add_development_dependency "bundler",  "~> 1.3"
   spec.add_development_dependency "rspec",    "~> 3.4.0"
   spec.add_development_dependency "webmock",  "~> 1.24.2"
   spec.add_development_dependency "rubocop",  "~> 0.39.0"

data/lib/influxdb/client/http.rb

@@ -27,7 +27,7 @@ module InfluxDB
         response = do_request http, Net::HTTP::Post.new(url, headers), data
 
         case response
-        when Net::HTTPSuccess
+        when Net::HTTPNoContent
           return response
         when Net::HTTPUnauthorized
           raise InfluxDB::AuthenticationError, response.body

data/lib/influxdb/config.rb

@@ -25,51 +25,22 @@ module InfluxDB
 
     attr_reader :async, :udp
 
-    # rubocop:disable all
     def initialize(opts = {})
-      @database         = opts[:database]
-      @port             = opts.fetch(:port, 8086)
-      @prefix           = opts.fetch(:prefix, "".freeze)
-      @username         = opts.fetch(:username, "root".freeze)
-      @password         = opts.fetch(:password, "root".freeze)
-      @auth_method      = AUTH_METHODS.include?(opts[:auth_method]) ? opts[:auth_method] : "params".freeze
-      @use_ssl          = opts.fetch(:use_ssl, false)
-      @verify_ssl       = opts.fetch(:verify_ssl, true)
-      @ssl_ca_cert      = opts.fetch(:ssl_ca_cert, false)
-      @time_precision   = opts.fetch(:time_precision, "s".freeze)
-      @initial_delay    = opts.fetch(:initial_delay, 0.01)
-      @max_delay        = opts.fetch(:max_delay, 30)
-      @open_timeout     = opts.fetch(:write_timeout, 5)
-      @read_timeout     = opts.fetch(:read_timeout, 300)
-      @async            = opts.fetch(:async, false)
-      @udp              = opts.fetch(:udp, false)
-      @retry            = opts.fetch(:retry, nil)
-      @denormalize      = opts.fetch(:denormalize, true)
-      @epoch            = opts.fetch(:epoch, false)
-
-      # load the hosts into a Queue for thread safety
-      @hosts_queue = Queue.new
-      Array(opts[:hosts] || opts[:host] || ["localhost"]).each do |host|
-        @hosts_queue.push(host)
-      end
+      extract_http_options!(opts)
+      extract_ssl_options!(opts)
+      extract_database_options!(opts)
+      extract_writer_options!(opts)
 
-      # normalize retry option
-      case @retry
-      when Integer
-        # ok
-      when true, nil
-        @retry = -1
-      when false
-        @retry = 0
-      end
+      configure_retry! opts.fetch(:retry, nil)
+      configure_hosts! opts[:hosts] || opts[:host] || "localhost".freeze
     end
 
     def udp?
-      !!udp
+      udp != false
     end
 
     def async?
-      !!async
+      async != false
     end
 
     def next_host
@@ -85,5 +56,59 @@ module InfluxDB
         host
       end
     end
+
+    private
+
+    # rubocop:disable Metrics/AbcSize
+    def extract_http_options!(opts)
+      @port           = opts.fetch :port, 8086
+      @prefix         = opts.fetch :prefix, "".freeze
+      @username       = opts.fetch :username, "root".freeze
+      @password       = opts.fetch :password, "root".freeze
+      @open_timeout   = opts.fetch :write_timeout, 5
+      @read_timeout   = opts.fetch :read_timeout, 300
+      @max_delay      = opts.fetch :max_delay, 30
+      @initial_delay  = opts.fetch :initial_delay, 0.01
+      auth            = opts[:auth_method]
+      @auth_method    = AUTH_METHODS.include?(auth) ? auth : "params".freeze
+    end
+
+    def extract_ssl_options!(opts)
+      @use_ssl      = opts.fetch :use_ssl, false
+      @verify_ssl   = opts.fetch :verify_ssl, true
+      @ssl_ca_cert  = opts.fetch :ssl_ca_cert, false
+    end
+
+    # normalize retry option
+    def configure_retry!(value)
+      case value
+      when Integer
+        @retry = value
+      when true, nil
+        @retry = -1
+      when false
+        @retry = 0
+      end
+    end
+
+    # load the hosts into a Queue for thread safety
+    def configure_hosts!(hosts)
+      @hosts_queue = Queue.new
+      Array(hosts).each do |host|
+        @hosts_queue.push(host)
+      end
+    end
+
+    def extract_database_options!(opts)
+      @database       = opts[:database]
+      @time_precision = opts.fetch :time_precision, "s".freeze
+      @denormalize    = opts.fetch :denormalize, true
+      @epoch          = opts.fetch :epoch, false
+    end
+
+    def extract_writer_options!(opts)
+      @async = opts.fetch :async, false
+      @udp   = opts.fetch :udp, false
+    end
   end
 end

data/lib/influxdb/version.rb

@@ -1,3 +1,3 @@
 module InfluxDB # :nodoc:
-  VERSION = "0.2.6".freeze
+  VERSION = "0.3.0".freeze
 end

data/lib/influxdb/writer/async.rb

@@ -29,19 +29,31 @@ module InfluxDB
       end
 
       class Worker
-        attr_reader :client, :queue, :threads
+        attr_reader :client,
+                    :queue,
+                    :threads,
+                    :max_post_points,
+                    :max_queue_size,
+                    :num_worker_threads,
+                    :sleep_interval
 
         include InfluxDB::Logging
 
-        MAX_POST_POINTS = 1000
-        MAX_QUEUE_SIZE = 10_000
-        NUM_WORKER_THREADS = 3
-        SLEEP_INTERVAL = 5
+        MAX_POST_POINTS     = 1000
+        MAX_QUEUE_SIZE      = 10_000
+        NUM_WORKER_THREADS  = 3
+        SLEEP_INTERVAL      = 5
 
         def initialize(client, config)
           @client = client
           config = config.is_a?(Hash) ? config : {}
-          @queue = InfluxDB::MaxQueue.new config.fetch(:max_queue, MAX_QUEUE_SIZE)
+
+          @max_post_points    = config.fetch(:max_post_points,    MAX_POST_POINTS)
+          @max_queue_size     = config.fetch(:max_queue_size,     MAX_QUEUE_SIZE)
+          @num_worker_threads = config.fetch(:num_worker_threads, NUM_WORKER_THREADS)
+          @sleep_interval     = config.fetch(:sleep_interval,     SLEEP_INTERVAL)
+
+          @queue = InfluxDB::MaxQueue.new max_queue_size
 
           spawn_threads!
         end
@@ -64,7 +76,7 @@ module InfluxDB
 
         def spawn_threads!
           @threads = []
-          NUM_WORKER_THREADS.times do |thread_num|
+          num_worker_threads.times do |thread_num|
             log :debug, "Spawning background worker thread #{thread_num}."
 
             @threads << Thread.new do
@@ -72,7 +84,7 @@ module InfluxDB
 
               until client.stopped?
                 check_background_queue(thread_num)
-                sleep rand(SLEEP_INTERVAL)
+                sleep rand(sleep_interval)
               end
 
               log :debug, "Exit background worker thread #{thread_num}."
@@ -87,7 +99,7 @@ module InfluxDB
           loop do
             data = []
 
-            while data.size < MAX_POST_POINTS && !queue.empty?
+            while data.size < max_post_points && !queue.empty?
               p = queue.pop(true) rescue next
               data.push p
             end
@@ -101,7 +113,7 @@ module InfluxDB
               puts "Cannot write data: #{e.inspect}"
             end
 
-            break if queue.length > MAX_POST_POINTS
+            break if queue.length > max_post_points
           end
         end
 

data/spec/influxdb/cases/async_client_spec.rb

@@ -2,17 +2,19 @@ require "spec_helper"
 require "timeout"
 
 describe InfluxDB::Client do
-  let(:subject) { described_class.new(async: true) }
+  let(:async_options) { true }
+  let(:client) { described_class.new(async: async_options) }
+  let(:subject) { client }
   let(:stub_url) { "http://localhost:8086/write?db=&p=root&precision=s&u=root" }
-  let(:worker_klass) { InfluxDB::Writer::Async::Worker }
+  let(:worker) { client.writer.worker }
 
   specify { expect(subject.writer).to be_a(InfluxDB::Writer::Async) }
 
   describe "#write_point" do
     it "sends writes to client" do
-      post_request = stub_request(:post, stub_url)
+      post_request = stub_request(:post, stub_url).to_return(status: 204)
 
-      (worker_klass::MAX_POST_POINTS + 100).times do
+      (worker.max_post_points + 100).times do
         subject.write_point('a', {})
       end
 
@@ -21,11 +23,11 @@ describe InfluxDB::Client do
       # responsive and needs a bit more time.
       timeout_stretch = ENV["TRAVIS"] == "true" ? 10 : 3
 
-      Timeout.timeout(timeout_stretch * worker_klass::SLEEP_INTERVAL) do
+      Timeout.timeout(timeout_stretch * worker.sleep_interval) do
         subject.stop!
       end
 
-      subject.writer.worker.threads.each do |t|
+      worker.threads.each do |t|
         expect(t.stop?).to be true
       end
 
@@ -34,4 +36,23 @@ describe InfluxDB::Client do
       expect(post_request).to have_been_requested.at_least_times(2)
     end
   end
+
+  describe "async options" do
+    let(:async_options) do
+      {
+        max_post_points:    10,
+        max_queue_size:     100,
+        num_worker_threads: 1,
+        sleep_interval:     0.5
+      }
+    end
+
+    subject { worker }
+    before { worker.stop! }
+
+    specify { expect(subject.max_post_points).to be 10 }
+    specify { expect(subject.max_queue_size).to be 100 }
+    specify { expect(subject.num_worker_threads).to be 1 }
+    specify { expect(subject.sleep_interval).to be_within(0.0001).of(0.5) }
+  end
 end

data/spec/influxdb/cases/query_core.rb

@@ -1,33 +1,35 @@
-require 'spec_helper'
-require 'json'
+require "spec_helper"
 
 describe InfluxDB::Client do
   let(:subject) do
-    described_class.new(
-      'database',
-      {
-        host: 'influxdb.test',
-        port: 9999,
-        username: 'username',
-        password: 'password',
-        time_precision: 's'
-      }.merge(args)
-    )
+    described_class.new "database", {
+      host: "influxdb.test",
+      port: 9999,
+      username: "username",
+      password: "password",
+      time_precision: "s"
+    }.merge(args)
   end
 
   let(:args) { {} }
 
-  describe '#query' do
+  describe "#query" do
+    let(:query) { "SELECT value FROM requests_per_minute WHERE time > 1437019900" }
+    let(:response) do
+      { "results" => [{ "series" => [{ "name" => "requests_per_minute",
+                                       "columns" => %w( time value ) }] }] }
+    end
+
+    before do
+      stub_request(:get, "http://influxdb.test:9999/query")
+        .with(query: { db: "database", precision: "s", u: "username", p: "password", q: query })
+        .to_return(body: JSON.generate(response), status: 200)
+    end
 
-    it 'should handle responses with no values' do
+    it "should handle responses with no values" do
       # Some requests (such as trying to retrieve values from the future)
-      # return a result with no 'values' key set.
-      query    = 'SELECT value FROM requests_per_minute WHERE time > 1437019900'
-      response = {'results'=>[{'series'=>[{'name'=>'requests_per_minute' ,'columns' => ['time','value']}]}]}
-      stub_request(:get, 'http://influxdb.test:9999/query').with(
-        query: { db: 'database', precision: 's', u: 'username', p: 'password', q: query }
-      ).to_return(body: JSON.generate(response), status: 200)
-      expected_result = [{'name'=>'requests_per_minute', 'tags'=>nil, 'values'=>[]}]
+      # return a result with no "values" key set.
+      expected_result = [{ "name" => "requests_per_minute", "tags" => nil, "values" => [] }]
       expect(subject.query(query)).to eq(expected_result)
     end
   end

data/spec/influxdb/cases/query_user_spec.rb

@@ -145,9 +145,9 @@ describe InfluxDB::Client do
     let(:list_query) { "SHOW GRANTS FOR #{user}" }
 
     before do
-      stub_request(:get, "http://influxdb.test:9999/query").with(
-        query: { u: "username", p: "password", q: list_query},
-      ).to_return(:status => 200, :body => "", :headers => {})
+      stub_request(:get, "http://influxdb.test:9999/query")
+        .with(query: { u: "username", p: "password", q: list_query })
+        .to_return(status: 200, body: "", headers: {})
     end
 
     it "should GET for a user" do

data/spec/influxdb/cases/querying_spec.rb

@@ -3,20 +3,25 @@ require "json"
 
 describe InfluxDB::Client do
   let(:subject) do
-    described_class.new(
-      "database",
-      {
-        host: "influxdb.test",
-        port: 9999,
-        username: "username",
-        password: "password",
-        time_precision: "s"
-      }.merge(args)
-    )
+    described_class.new "database", {
+      host: "influxdb.test",
+      port: 9999,
+      username: "username",
+      password: "password",
+      time_precision: "s"
+    }.merge(args)
   end
 
-  let(:args) { {} }
-  let(:database) { subject.config.database }
+  let(:args)          { {} }
+  let(:database)      { subject.config.database }
+  let(:extra_params)  { {} }
+  let(:response)      {}
+
+  before do
+    stub_request(:get, "http://influxdb.test:9999/query")
+      .with(query: { q: query, u: "username", p: "password", precision: 's', db: database }.merge(extra_params))
+      .to_return(body: JSON.generate(response))
+  end
 
   describe "#query" do
     context "with single series with multiple points" do
@@ -32,12 +37,6 @@ describe InfluxDB::Client do
       end
       let(:query) { 'SELECT * FROM cpu' }
 
-      before do
-        stub_request(:get, "http://influxdb.test:9999/query").with(
-          query: { q: query, u: "username", p: "password", precision: 's', db: database }
-        ).to_return(body: JSON.generate(response))
-      end
-
       it "should return array with single hash containing multiple values" do
         expect(subject.query(query)).to eq(expected_result)
       end
@@ -45,8 +44,8 @@ describe InfluxDB::Client do
 
     context "with series with different tags" do
       let(:response) do
-        { "results" =>           [{ "series" =>             [{ "name" => "cpu", "tags" => { "region" => "pl" }, "columns" => %w(time temp value), "values" => [["2015-07-07T15:13:04Z", 34, 0.343443]] },
-                                                             { "name" => "cpu", "tags" => { "region" => "us" }, "columns" => %w(time temp value), "values" => [["2015-07-07T14:58:37Z", 92, 0.3445], ["2015-07-07T14:59:09Z", 68, 0.8787]] }] }] }
+        { "results" => [{ "series" => [{ "name" => "cpu", "tags" => { "region" => "pl" }, "columns" => %w(time temp value), "values" => [["2015-07-07T15:13:04Z", 34, 0.343443]] },
+                                       { "name" => "cpu", "tags" => { "region" => "us" }, "columns" => %w(time temp value), "values" => [["2015-07-07T14:58:37Z", 92, 0.3445], ["2015-07-07T14:59:09Z", 68, 0.8787]] }] }] }
       end
       let(:expected_result) do
         [{ "name" => "cpu", "tags" => { "region" => "pl" },
@@ -57,12 +56,6 @@ describe InfluxDB::Client do
       end
       let(:query) { 'SELECT * FROM cpu' }
 
-      before do
-        stub_request(:get, "http://influxdb.test:9999/query").with(
-          query: { q: query, u: "username", p: "password", precision: 's', db: database }
-        ).to_return(body: JSON.generate(response))
-      end
-
       it "should return array with 2 elements grouped by tags" do
         expect(subject.query(query)).to eq(expected_result)
       end
@@ -70,10 +63,10 @@ describe InfluxDB::Client do
 
     context "with multiple series with different tags" do
       let(:response) do
-        { "results" =>           [{ "series" =>             [{ "name" => "access_times.service_1", "tags" => { "code" => "200", "result" => "failure", "status" => "OK" }, "columns" => %w(time value), "values" => [["2015-07-08T07:15:22Z", 327]] },
-                                                             { "name" => "access_times.service_1", "tags" => { "code" => "500", "result" => "failure", "status" => "Internal Server Error" }, "columns" => %w(time value), "values" => [["2015-07-08T06:15:22Z", 873]] },
-                                                             { "name" => "access_times.service_2", "tags" => { "code" => "200", "result" => "failure", "status" => "OK" }, "columns" => %w(time value), "values" => [["2015-07-08T07:15:22Z", 943]] },
-                                                             { "name" => "access_times.service_2", "tags" => { "code" => "500", "result" => "failure", "status" => "Internal Server Error" }, "columns" => %w(time value), "values" => [["2015-07-08T06:15:22Z", 606]] }] }] }
+        { "results" => [{ "series" => [{ "name" => "access_times.service_1", "tags" => { "code" => "200", "result" => "failure", "status" => "OK" }, "columns" => %w(time value), "values" => [["2015-07-08T07:15:22Z", 327]] },
+                                       { "name" => "access_times.service_1", "tags" => { "code" => "500", "result" => "failure", "status" => "Internal Server Error" }, "columns" => %w(time value), "values" => [["2015-07-08T06:15:22Z", 873]] },
+                                       { "name" => "access_times.service_2", "tags" => { "code" => "200", "result" => "failure", "status" => "OK" }, "columns" => %w(time value), "values" => [["2015-07-08T07:15:22Z", 943]] },
+                                       { "name" => "access_times.service_2", "tags" => { "code" => "500", "result" => "failure", "status" => "Internal Server Error" }, "columns" => %w(time value), "values" => [["2015-07-08T06:15:22Z", 606]] }] }] }
       end
       let(:expected_result) do
         [{ "name" => "access_times.service_1", "tags" => { "code" => "200", "result" => "failure", "status" => "OK" }, "values" => [{ "time" => "2015-07-08T07:15:22Z", "value" => 327 }] },
@@ -83,12 +76,6 @@ describe InfluxDB::Client do
       end
       let(:query) { "SELECT * FROM /access_times.*/" }
 
-      before do
-        stub_request(:get, "http://influxdb.test:9999/query").with(
-          query: { q: query, u: "username", p: "password", precision: 's', db: database }
-        ).to_return(body: JSON.generate(response))
-      end
-
       it "should return array with 4 elements grouped by name and tags" do
         expect(subject.query(query)).to eq(expected_result)
       end
@@ -96,8 +83,8 @@ describe InfluxDB::Client do
 
     context "with multiple series for explicit value only" do
       let(:response) do
-        { "results" =>           [{ "series" =>              [{ "name" => "access_times.service_1", "columns" => %w(time value), "values" => [["2015-07-08T06:15:22Z", 873], ["2015-07-08T07:15:22Z", 327]] },
-                                                              { "name" => "access_times.service_2", "columns" => %w(time value), "values" => [["2015-07-08T06:15:22Z", 606], ["2015-07-08T07:15:22Z", 943]] }] }] }
+        { "results" => [{ "series" => [{ "name" => "access_times.service_1", "columns" => %w(time value), "values" => [["2015-07-08T06:15:22Z", 873], ["2015-07-08T07:15:22Z", 327]] },
+                                       { "name" => "access_times.service_2", "columns" => %w(time value), "values" => [["2015-07-08T06:15:22Z", 606], ["2015-07-08T07:15:22Z", 943]] }] }] }
       end
       let(:expected_result) do
         [{ "name" => "access_times.service_1", "tags" => nil, "values" => [{ "time" => "2015-07-08T06:15:22Z", "value" => 873 }, { "time" => "2015-07-08T07:15:22Z", "value" => 327 }] },
@@ -105,12 +92,6 @@ describe InfluxDB::Client do
       end
       let(:query) { "SELECT value FROM /access_times.*/" }
 
-      before do
-        stub_request(:get, "http://influxdb.test:9999/query").with(
-          query: { q: query, u: "username", p: "password", precision: 's', db: database }
-        ).to_return(body: JSON.generate(response))
-      end
-
       it "should return array with 2 elements grouped by name only and no tags" do
         expect(subject.query(query)).to eq(expected_result)
       end
@@ -118,8 +99,8 @@ describe InfluxDB::Client do
 
     context "with a block" do
       let(:response) do
-        { "results" =>           [{ "series" =>             [{ "name" => "cpu", "tags" => { "region" => "pl" }, "columns" => %w(time temp value), "values" => [["2015-07-07T15:13:04Z", 34, 0.343443]] },
-                                                             { "name" => "cpu", "tags" => { "region" => "us" }, "columns" => %w(time temp value), "values" => [["2015-07-07T14:58:37Z", 92, 0.3445], ["2015-07-07T14:59:09Z", 68, 0.8787]] }] }] }
+        { "results" => [{ "series" => [{ "name" => "cpu", "tags" => { "region" => "pl" }, "columns" => %w(time temp value), "values" => [["2015-07-07T15:13:04Z", 34, 0.343443]] },
+                                       { "name" => "cpu", "tags" => { "region" => "us" }, "columns" => %w(time temp value), "values" => [["2015-07-07T14:58:37Z", 92, 0.3445], ["2015-07-07T14:59:09Z", 68, 0.8787]] }] }] }
       end
 
       let(:expected_result) do
@@ -131,12 +112,6 @@ describe InfluxDB::Client do
       end
       let(:query) { 'SELECT * FROM cpu' }
 
-      before do
-        stub_request(:get, "http://influxdb.test:9999/query").with(
-          query: { q: query, u: "username", p: "password", precision: 's', db: database }
-        ).to_return(body: JSON.generate(response))
-      end
-
       it "should accept a block and yield name, tags and points" do
         results = []
         subject.query(query) do |name, tags, points|
@@ -147,33 +122,23 @@ describe InfluxDB::Client do
     end
 
     context "with epoch set to seconds" do
-      let(:args) { {epoch: 's'} }
+      let(:args) { { epoch: 's' } }
+      let(:extra_params) { { epoch: 's' } }
 
       let(:response) do
-        { "results" =>
-          [{ "series" =>
-            [{ "name" => "cpu", "tags" => { "region" => "pl" }, "columns" => %w(time temp value), "values" => [[1438580576, 34, 0.343443]] },
-             { "name" => "cpu", "tags" => { "region" => "us" }, "columns" => %w(time temp value), "values" => [[1438612976, 92, 0.3445], [1438612989, 68, 0.8787]] }
-            ]
-          }]
-        }
+        { "results" => [{ "series" => [{ "name" => "cpu", "tags" => { "region" => "pl" }, "columns" => %w(time temp value), "values" => [[1_438_580_576, 34, 0.343443]] },
+                                       { "name" => "cpu", "tags" => { "region" => "us" }, "columns" => %w(time temp value), "values" => [[1_438_612_976, 92, 0.3445], [1_438_612_989, 68, 0.8787]] }] }] }
       end
       let(:expected_result) do
         [{ "name" => "cpu", "tags" => { "region" => "pl" },
-           "values" => [{ "time" => 1438580576, "temp" => 34, "value" => 0.343443 }] },
+           "values" => [{ "time" => 1_438_580_576, "temp" => 34, "value" => 0.343443 }] },
          { "name" => "cpu", "tags" => { "region" => "us" },
-           "values" => [{ "time" => 1438612976, "temp" => 92, "value" => 0.3445 },
-                        { "time" => 1438612989, "temp" => 68, "value" => 0.8787 }]
+           "values" => [{ "time" => 1_438_612_976, "temp" => 92, "value" => 0.3445 },
+                        { "time" => 1_438_612_989, "temp" => 68, "value" => 0.8787 }]
         }]
       end
       let(:query) { 'SELECT * FROM cpu' }
 
-      before do
-        stub_request(:get, "http://influxdb.test:9999/query").with(
-          query: { q: query, u: "username", p: "password", precision: 's', db: database, epoch: 's' }
-        ).to_return(body: JSON.generate(response))
-      end
-
       it "should return results with integer timestamp" do
         expect(subject.query(query)).to eq(expected_result)
       end
@@ -188,24 +153,18 @@ describe InfluxDB::Client do
                                          "values" => [["2015-07-07T14:58:37Z", 92, 0.3445], ["2015-07-07T14:59:09Z", 68, 0.8787]] }] },
                         { "series" => [{ "name" => "memory", "tags" => { "region" => "us" },
                                          "columns" => %w(time free total),
-                                         "values" => [["2015-07-07T14:58:37Z", 96468992, 134217728], ["2015-07-07T14:59:09Z", 71303168, 134217728]] }] }] }
+                                         "values" => [["2015-07-07T14:58:37Z", 96_468_992, 134_217_728], ["2015-07-07T14:59:09Z", 71_303_168, 134_217_728]] }] }] }
       end
       let(:expected_result) do
         [{ "name" => "cpu", "tags" => { "region" => "us" },
            "values" => [{ "time" => "2015-07-07T14:58:37Z", "temp" => 92, "value" => 0.3445 },
                         { "time" => "2015-07-07T14:59:09Z", "temp" => 68, "value" => 0.8787 }] },
          { "name" => "memory", "tags" => { "region" => "us" },
-           "values" => [{ "time" => "2015-07-07T14:58:37Z", "free" => 92*2**20, "total" => 128*2**20 },
-                        { "time" => "2015-07-07T14:59:09Z", "free" => 68*2**20, "total" => 128*2**20 }] }]
+           "values" => [{ "time" => "2015-07-07T14:58:37Z", "free" => 92 * 2**20, "total" => 128 * 2**20 },
+                        { "time" => "2015-07-07T14:59:09Z", "free" => 68 * 2**20, "total" => 128 * 2**20 }] }]
       end
       let(:query) { 'SELECT * FROM cpu; SELECT * FROM memory' }
 
-      before do
-        stub_request(:get, "http://influxdb.test:9999/query").with(
-          query: { q: query, u: "username", p: "password", precision: 's', db: database }
-        ).to_return(body: JSON.generate(response))
-      end
-
       it "should return array with single hash containing multiple values" do
         expect(subject.query(query)).to eq(expected_result)
       end
@@ -213,10 +172,10 @@ describe InfluxDB::Client do
 
     context "with series with different tags" do
       let(:response) do
-        { "results" =>           [{ "series" =>             [{ "name" => "cpu", "tags" => { "region" => "pl" }, "columns" => %w(time temp value), "values" => [["2015-07-07T15:13:04Z", 34, 0.343443]] },
-                                                             { "name" => "cpu", "tags" => { "region" => "us" }, "columns" => %w(time temp value), "values" => [["2015-07-07T14:58:37Z", 92, 0.3445], ["2015-07-07T14:59:09Z", 68, 0.8787]] }] },
-                                  { "series" =>             [{ "name" => "memory", "tags" => { "region" => "pl" }, "columns" => %w(time free total), "values" => [["2015-07-07T15:13:04Z", 35651584, 134217728]] },
-                                                             { "name" => "memory", "tags" => { "region" => "us" }, "columns" => %w(time free total), "values" => [["2015-07-07T14:58:37Z", 96468992, 134217728], ["2015-07-07T14:59:09Z", 71303168, 134217728]] }] }] }
+        { "results" => [{ "series" => [{ "name" => "cpu", "tags" => { "region" => "pl" }, "columns" => %w(time temp value), "values" => [["2015-07-07T15:13:04Z", 34, 0.343443]] },
+                                       { "name" => "cpu", "tags" => { "region" => "us" }, "columns" => %w(time temp value), "values" => [["2015-07-07T14:58:37Z", 92, 0.3445], ["2015-07-07T14:59:09Z", 68, 0.8787]] }] },
+                        { "series" => [{ "name" => "memory", "tags" => { "region" => "pl" }, "columns" => %w(time free total), "values" => [["2015-07-07T15:13:04Z", 35_651_584, 134_217_728]] },
+                                       { "name" => "memory", "tags" => { "region" => "us" }, "columns" => %w(time free total), "values" => [["2015-07-07T14:58:37Z", 96_468_992, 134_217_728], ["2015-07-07T14:59:09Z", 71_303_168, 134_217_728]] }] }] }
       end
       let(:expected_result) do
         [{ "name" => "cpu", "tags" => { "region" => "pl" },
@@ -225,19 +184,13 @@ describe InfluxDB::Client do
            "values" => [{ "time" => "2015-07-07T14:58:37Z", "temp" => 92, "value" => 0.3445 },
                         { "time" => "2015-07-07T14:59:09Z", "temp" => 68, "value" => 0.8787 }] },
          { "name" => "memory", "tags" => { "region" => "pl" },
-           "values" => [{ "time" => "2015-07-07T15:13:04Z", "free" => 34*2**20, "total" => 128*2**20 }] },
+           "values" => [{ "time" => "2015-07-07T15:13:04Z", "free" => 34 * 2**20, "total" => 128 * 2**20 }] },
          { "name" => "memory", "tags" => { "region" => "us" },
-           "values" => [{ "time" => "2015-07-07T14:58:37Z", "free" => 92*2**20, "total" => 128*2**20 },
-                        { "time" => "2015-07-07T14:59:09Z", "free" => 68*2**20, "total" => 128*2**20 }] }]
+           "values" => [{ "time" => "2015-07-07T14:58:37Z", "free" => 92 * 2**20, "total" => 128 * 2**20 },
+                        { "time" => "2015-07-07T14:59:09Z", "free" => 68 * 2**20, "total" => 128 * 2**20 }] }]
       end
       let(:query) { 'SELECT * FROM cpu; SELECT * FROM memory' }
 
-      before do
-        stub_request(:get, "http://influxdb.test:9999/query").with(
-          query: { q: query, u: "username", p: "password", precision: 's', db: database }
-        ).to_return(body: JSON.generate(response))
-      end
-
       it "should return array with 2 elements grouped by tags" do
         expect(subject.query(query)).to eq(expected_result)
       end
@@ -245,10 +198,10 @@ describe InfluxDB::Client do
 
     context "with a block" do
       let(:response) do
-        { "results" =>           [{ "series" =>             [{ "name" => "cpu", "tags" => { "region" => "pl" }, "columns" => %w(time temp value), "values" => [["2015-07-07T15:13:04Z", 34, 0.343443]] },
-                                                             { "name" => "cpu", "tags" => { "region" => "us" }, "columns" => %w(time temp value), "values" => [["2015-07-07T14:58:37Z", 92, 0.3445], ["2015-07-07T14:59:09Z", 68, 0.8787]] }] },
-                                  { "series" =>             [{ "name" => "memory", "tags" => { "region" => "pl" }, "columns" => %w(time free total), "values" => [["2015-07-07T15:13:04Z", 35651584, 134217728]] },
-                                                             { "name" => "memory", "tags" => { "region" => "us" }, "columns" => %w(time free total), "values" => [["2015-07-07T14:58:37Z", 96468992, 134217728], ["2015-07-07T14:59:09Z", 71303168, 134217728]] }] }] }
+        { "results" => [{ "series" => [{ "name" => "cpu", "tags" => { "region" => "pl" }, "columns" => %w(time temp value), "values" => [["2015-07-07T15:13:04Z", 34, 0.343443]] },
+                                       { "name" => "cpu", "tags" => { "region" => "us" }, "columns" => %w(time temp value), "values" => [["2015-07-07T14:58:37Z", 92, 0.3445], ["2015-07-07T14:59:09Z", 68, 0.8787]] }] },
+                        { "series" => [{ "name" => "memory", "tags" => { "region" => "pl" }, "columns" => %w(time free total), "values" => [["2015-07-07T15:13:04Z", 35_651_584, 134_217_728]] },
+                                       { "name" => "memory", "tags" => { "region" => "us" }, "columns" => %w(time free total), "values" => [["2015-07-07T14:58:37Z", 96_468_992, 134_217_728], ["2015-07-07T14:59:09Z", 71_303_168, 134_217_728]] }] }] }
       end
 
       let(:expected_result) do
@@ -258,19 +211,13 @@ describe InfluxDB::Client do
            "values" => [{ "time" => "2015-07-07T14:58:37Z", "temp" => 92, "value" => 0.3445 },
                         { "time" => "2015-07-07T14:59:09Z", "temp" => 68, "value" => 0.8787 }] },
          { "name" => "memory", "tags" => { "region" => "pl" },
-           "values" => [{ "time" => "2015-07-07T15:13:04Z", "free" => 34*2**20, "total" => 128*2**20 }] },
+           "values" => [{ "time" => "2015-07-07T15:13:04Z", "free" => 34 * 2**20, "total" => 128 * 2**20 }] },
          { "name" => "memory", "tags" => { "region" => "us" },
-           "values" => [{ "time" => "2015-07-07T14:58:37Z", "free" => 92*2**20, "total" => 128*2**20 },
-                        { "time" => "2015-07-07T14:59:09Z", "free" => 68*2**20, "total" => 128*2**20 }] }]
+           "values" => [{ "time" => "2015-07-07T14:58:37Z", "free" => 92 * 2**20, "total" => 128 * 2**20 },
+                        { "time" => "2015-07-07T14:59:09Z", "free" => 68 * 2**20, "total" => 128 * 2**20 }] }]
       end
       let(:query) { 'SELECT * FROM cpu; SELECT * FROM memory' }
 
-      before do
-        stub_request(:get, "http://influxdb.test:9999/query").with(
-          query: { q: query, u: "username", p: "password", precision: 's', db: database }
-        ).to_return(body: JSON.generate(response))
-      end
-
       it "should accept a block and yield name, tags and points" do
         results = []
         subject.query(query) do |name, tags, points|

data/spec/influxdb/cases/retry_requests_spec.rb

@@ -23,7 +23,7 @@ describe InfluxDB::Client do
     let(:series) { "cpu" }
     let(:data) do
       { tags: { region: 'us', host: 'server_1' },
-        values: { temp: 88,  value: 54 } }
+        values: { temp: 88, value: 54 } }
     end
     let(:body) do
       InfluxDB::PointValue.new(data.merge(series: series)).dump
@@ -72,15 +72,17 @@ describe InfluxDB::Client do
     context "when retry is -1" do
       let(:args) { { retry: -1 } }
       before do
-        stub_request(:post, "http://influxdb.test:9999/write").with(
-          query: { u: "username", p: "password", precision: 's', db: database },
-          headers: { "Content-Type" => "application/octet-stream" },
-          body: body
-        ).to_raise(Timeout::Error).then
+        stub_request(:post, "http://influxdb.test:9999/write")
+          .with(
+            query: { u: "username", p: "password", precision: 's', db: database },
+            headers: { "Content-Type" => "application/octet-stream" },
+            body: body
+          )
           .to_raise(Timeout::Error).then
           .to_raise(Timeout::Error).then
           .to_raise(Timeout::Error).then
-          .to_return(status: 200)
+          .to_raise(Timeout::Error).then
+          .to_return(status: 204)
       end
 
       it "keep trying until get the connection" do

data/spec/influxdb/cases/write_points_spec.rb

@@ -3,16 +3,13 @@ require "json"
 
 describe InfluxDB::Client do
   let(:subject) do
-    described_class.new(
-      "database",
-      {
-        host: "influxdb.test",
-        port: 9999,
-        username: "username",
-        password: "password",
-        time_precision: "s"
-      }.merge(args)
-    )
+    described_class.new "database", {
+      host: "influxdb.test",
+      port: 9999,
+      username: "username",
+      password: "password",
+      time_precision: "s"
+    }.merge(args)
   end
 
   let(:args) { {} }
@@ -23,7 +20,7 @@ describe InfluxDB::Client do
     let(:series) { "cpu" }
     let(:data) do
       { tags: { region: 'us', host: 'server_1' },
-        values: { temp: 88,  value: 54 } }
+        values: { temp: 88, value: 54 } }
     end
     let(:body) do
       InfluxDB::PointValue.new(data.merge(series: series)).dump
@@ -34,11 +31,11 @@ describe InfluxDB::Client do
         query: { u: "username", p: "password", precision: 's', db: database },
         headers: { "Content-Type" => "application/octet-stream" },
         body: body
-      )
+      ).to_return(status: 204)
     end
 
     it "should POST to add single point" do
-      expect(subject.write_point(series, data)).to be_a(Net::HTTPOK)
+      expect(subject.write_point(series, data)).to be_a(Net::HTTPNoContent)
     end
 
     it "should not mutate data object" do
@@ -52,16 +49,12 @@ describe InfluxDB::Client do
   describe "#write_points" do
     context "with multiple series" do
       let(:data) do
-        [{
-          series: 'cpu',
-          tags: {  region: 'us', host: 'server_1' },
-          values: { temp: 88, value: 54 }
-        },
-         {
-           series: 'gpu',
-           tags: { region: 'uk',  host: 'server_5' },
-           values: { value: 0.5435345 }
-         }]
+        [{ series: 'cpu',
+           tags: { region: 'us', host: 'server_1' },
+           values: { temp: 88, value: 54 } },
+         { series: 'gpu',
+           tags: { region: 'uk', host: 'server_5' },
+           values: { value: 0.5435345 } }]
       end
       let(:body) do
         data.map do |point|
@@ -74,24 +67,20 @@ describe InfluxDB::Client do
           query: { u: "username", p: "password", precision: 's', db: database },
           headers: { "Content-Type" => "application/octet-stream" },
           body: body
-        )
+        ).to_return(status: 204)
       end
 
       it "should POST multiple points" do
-        expect(subject.write_points(data)).to be_a(Net::HTTPOK)
+        expect(subject.write_points(data)).to be_a(Net::HTTPNoContent)
       end
     end
 
     context "with no tags" do
       let(:data) do
-        [{
-          series: 'cpu',
-          values: { temp: 88,  value: 54 }
-        },
-         {
-           series: 'gpu',
-           values: { value: 0.5435345 }
-         }]
+        [{ series: 'cpu',
+           values: { temp: 88, value: 54 } },
+         { series: 'gpu',
+           values: { value: 0.5435345 } }]
       end
       let(:body) do
         data.map do |point|
@@ -104,26 +93,22 @@ describe InfluxDB::Client do
           query: { u: "username", p: "password", precision: 's', db: database },
           headers: { "Content-Type" => "application/octet-stream" },
           body: body
-        )
+        ).to_return(status: 204)
       end
 
       it "should POST multiple points" do
-        expect(subject.write_points(data)).to be_a(Net::HTTPOK)
+        expect(subject.write_points(data)).to be_a(Net::HTTPNoContent)
       end
     end
 
     context "with time precision set to milisceconds" do
       let(:data) do
-        [{
-          series: 'cpu',
-          values: { temp: 88,  value: 54 },
-          timestamp: (Time.now.to_f * 1000).to_i
-        },
-         {
-           series: 'gpu',
+        [{ series: 'cpu',
+           values: { temp: 88, value: 54 },
+           timestamp: (Time.now.to_f * 1000).to_i },
+         { series: 'gpu',
            values: { value: 0.5435345 },
-           timestamp: (Time.now.to_f * 1000).to_i
-         }]
+           timestamp: (Time.now.to_f * 1000).to_i }]
       end
 
       let(:body) do
@@ -137,23 +122,19 @@ describe InfluxDB::Client do
           query: { u: "username", p: "password", precision: 'm', db: database },
           headers: { "Content-Type" => "application/octet-stream" },
           body: body
-        )
+        ).to_return(status: 204)
       end
       it "should POST multiple points" do
-        expect(subject.write_points(data, 'm')).to be_a(Net::HTTPOK)
+        expect(subject.write_points(data, 'm')).to be_a(Net::HTTPNoContent)
       end
     end
 
     context "with retention policy" do
       let(:data) do
-        [{
-          series: 'cpu',
-          values: { temp: 88,  value: 54 }
-        },
-         {
-           series: 'gpu',
-           values: { value: 0.5435345 }
-         }]
+        [{ series: 'cpu',
+           values: { temp: 88, value: 54 } },
+         { series: 'gpu',
+           values: { value: 0.5435345 } }]
       end
 
       let(:body) do
@@ -167,10 +148,10 @@ describe InfluxDB::Client do
           query: { u: "username", p: "password", precision: 's', db: database, rp: 'rp_1_hour' },
           headers: { "Content-Type" => "application/octet-stream" },
           body: body
-        )
+        ).to_return(status: 204)
       end
       it "should POST multiple points" do
-        expect(subject.write_points(data, nil, 'rp_1_hour')).to be_a(Net::HTTPOK)
+        expect(subject.write_points(data, nil, 'rp_1_hour')).to be_a(Net::HTTPNoContent)
       end
     end
   end

data/spec/influxdb/client_spec.rb

@@ -31,8 +31,8 @@ describe InfluxDB::Client do
     end
 
     it "POST" do
-      stub_request(:post, stub_url)
-      expect(subject.post(url, {})).to be_a(Net::HTTPOK)
+      stub_request(:post, stub_url).to_return(status: 204)
+      expect(subject.post(url, {})).to be_a(Net::HTTPNoContent)
     end
   end
 
@@ -66,8 +66,8 @@ describe InfluxDB::Client do
 
   describe "GET #version" do
     it "returns 1.1.1" do
-      stub_request(:get, "http://influxdb.test:9999/ping").to_return(
-        { :status => 204, :headers => {'x-influxdb-version' => '1.1.1'} })
+      stub_request(:get, "http://influxdb.test:9999/ping")
+        .to_return(status: 204, headers: { 'x-influxdb-version' => '1.1.1' })
 
       expect(subject.version).to eq('1.1.1')
     end

data/spec/influxdb/logging_spec.rb

@@ -10,8 +10,11 @@ describe InfluxDB::Logging do
     end
   end
 
-  before { @old_logger = InfluxDB::Logging.logger }
-  after { InfluxDB::Logging.logger = @old_logger }
+  around do |example|
+    old_logger = InfluxDB::Logging.logger
+    example.call
+    InfluxDB::Logging.logger = old_logger
+  end
 
   it "has a default logger" do
     expect(InfluxDB::Logging.logger).to be_a(Logger)

data/spec/influxdb/point_value_spec.rb

@@ -5,14 +5,14 @@ describe InfluxDB::PointValue do
     let(:data) do
       {
         series: '1= ,"\\1',
-        tags: {'2= ,"\\2' => '3= ,"\\3'},
-        values: {'4= ,"\\4' => '5= ,"\\5'},
+        tags: { '2= ,"\\2' => '3= ,"\\3' },
+        values: { '4= ,"\\4' => '5= ,"\\5' }
       }
     end
 
     it 'should escape correctly' do
       point = InfluxDB::PointValue.new(data)
-      expected = %(1=\\ \\,"\\1,2\\=\\ \\,"\\2=3\\=\\ \\,"\\3 )+
+      expected = %(1=\\ \\,"\\1,2\\=\\ \\,"\\2=3\\=\\ \\,"\\3 ) +
                  %(4\\=\\ \\,\\"\\4="5= ,\\"\\5")
       expect(point.dump).to eq(expected)
     end

data/spec/spec_helper.rb

@@ -8,6 +8,7 @@ end
 RSpec.configure do |config|
   config.color = ENV["TRAVIS"] != "true"
 
+  # rubocop:disable Style/ConditionalAssignment
   if config.files_to_run.one? || ENV["TRAVIS"] == "true"
     config.formatter = :documentation
   else
@@ -19,8 +20,8 @@ RSpec.configure do |config|
     logfile = File.open("tmp/spec.log", File::WRONLY | File::TRUNC | File::CREAT)
 
     InfluxDB::Logging.logger = Logger.new(logfile).tap do |logger|
-      logger.formatter = ->(severity, _datetime, progname, message) {
-        "%-5s - %s: %s\n" % [ severity, progname, message ]
+      logger.formatter = proc {|severity, _datetime, progname, message|
+        "%-5s - %s: %s\n".format severity, progname, message
       }
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: influxdb
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.3.0
 platform: ruby
 authors:
 - Todd Persen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-14 00:00:00.000000000 Z
+date: 2016-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -25,33 +25,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -104,6 +104,7 @@ files:
 - ".gitignore"
 - ".rubocop.yml"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md