influxdb-client 1.0.0.pre.121 → 1.0.0.pre.159

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 37721226ace63cea9b14c9e7cbb6474c44406f1d96bce46fcde735f9a7f47de3
-  data.tar.gz: 529302573c9122ea91301dec3cca2738ed7bfa1e106ca0ed59765e6d8948c1f6
+  metadata.gz: 7ffb84415d36902228797e8a00d2ac07e8c6330bd6020fc313ab14cb4c2217ac
+  data.tar.gz: e9933199fb5be92f37cd26c933047cf630fb493ca246c1266436500686575561
 SHA512:
-  metadata.gz: 6c2dbe6f3efdc655d6bf322b1a698da6951d9cf5c019ac0b4eda389b31ec70550ad5c0af88a34e3a0bfa733c56c81ced06911cb2f1176cd07be3a0e9f7a8eb9e
-  data.tar.gz: 73053187a5d3af888d542fc71428a56e0a48c998df4743265b24fc4ae6f02e75e90a978db00c060ffdb9df109c9e2b29a947fbf18d7ee3fc3e4caf21c1559126
+  metadata.gz: 110ad7524b27e5d686417f52d847c8e15a9616d3ee5f0da6adbab0eabaf2b847baa85457c987799e35cf861bbc3516830fb0ea6f69f4c1d4bccfade9b9e157f0
+  data.tar.gz: e5d5a833f9b0b9abdddf9f742ace87855032e8f3dfaa5ff109493ba259601fbed3f63d9be5d3afef989f16a8948bb3cb3c529ff5e74f69505c087f32799ac4f5

data/.circleci/config.yml

@@ -48,7 +48,8 @@ commands:
           name: Install dependencies
           command: |
             gem install bundler
-            bundle install --jobs=4 --retry=3 --path vendor/bundle
+            bundle config set path 'vendor/bundle'
+            bundle install --jobs=4 --retry=3
       - run:
           name: Static code analyze
           command: |
@@ -75,9 +76,12 @@ jobs:
       ruby-image:
         type: string
         default: &default-ruby-image "circleci/ruby:2.6-stretch"
+      influxdb-image:
+        type: string
+        default: &default-influxdb-image "influxdb:2.0.0-beta"
     docker:
       - image: << parameters.ruby-image >>
-      - image: &influx-image quay.io/influxdb/influx:nightly
+      - image: &influx-image quay.io/influxdb/<< parameters.influxdb-image >>
     steps:
       - prepare
       - test:
@@ -85,6 +89,10 @@ jobs:
       - storing-test-results
 
   deploy-preview:
+    parameters:
+      influxdb-image:
+        type: string
+        default: *default-influxdb-image
     docker:
       - image: *default-ruby-image
       - image: *influx-image
@@ -112,8 +120,14 @@ workflows:
   version: 2
   build:
     jobs:
+      - tests-ruby:
+          name: ruby-2.7
+          ruby-image: "circleci/ruby:2.7-buster"
       - tests-ruby:
           name: ruby-2.6
+      - tests-ruby:
+          name: ruby-2.6-nightly
+          influxdb-image: "influx:nightly"
       - tests-ruby:
           name: ruby-2.5
           ruby-image: "circleci/ruby:2.5-stretch"
@@ -122,7 +136,9 @@ workflows:
           ruby-image: "circleci/ruby:2.4-stretch"
       - deploy-preview:
           requires:
+            - ruby-2.7
             - ruby-2.6
+            - ruby-2.6-nightly
             - ruby-2.5
             - ruby-2.4
           filters:
@@ -138,4 +154,4 @@ workflows:
               only:
                 - master
     jobs:
-      - tests-ruby
+      - tests-ruby

data/README.md

@@ -10,6 +10,7 @@
 This repository contains the reference Ruby client for the InfluxDB 2.0.
 
 #### Note: This library is for use with InfluxDB 2.x. For connecting to InfluxDB 1.x instances, please use the [influxdb-ruby](https://github.com/influxdata/influxdb-ruby) client.
+#### Disclaimer: This library is a work in progress and should not be considered production ready yet.
 
 ## Installation
 
@@ -32,7 +33,7 @@ gem install influxdb-client --pre
 Use **InfluxDB::Client** to create a client connected to a running InfluxDB 2 instance.
 
 ```ruby
-client = InfluxDB::Client.new('https://localhost:9999', 'my-token')
+client = InfluxDB2::Client.new('https://localhost:9999', 'my-token')
 ```
 
 #### Client Options
@@ -49,19 +50,19 @@ client = InfluxDB::Client.new('https://localhost:9999', 'my-token')
 | use_ssl | Turn on/off SSL for HTTP communication | bool | true |
 
 ```ruby
-client = InfluxDB::Client.new('https://localhost:9999', 'my-token',
+client = InfluxDB2::Client.new('https://localhost:9999', 'my-token',
   bucket: 'my-bucket',
   org: 'my-org',
-  precision: InfluxDB::WritePrecision::NANOSECOND)
+  precision: InfluxDB2::WritePrecision::NANOSECOND)
 ```
 
 ### Writing data
 
 ```ruby
-client = InfluxDB::Client.new('https://localhost:9999', 'my-token',
+client = InfluxDB2::Client.new('https://localhost:9999', 'my-token',
                               bucket: 'my-bucket',
                               org: 'my-org',
-                              precision: InfluxDB::WritePrecision::NANOSECOND)
+                              precision: InfluxDB2::WritePrecision::NANOSECOND)
 
 write_api = client.create_write_api
 write_api.write(data: 'h2o,location=west value=33i 15')
@@ -71,20 +72,20 @@ write_api.write(data: 'h2o,location=west value=33i 15')
 
 Configure default time precision:
 ```ruby
-client = InfluxDB::Client.new('https://localhost:9999', 'my-token',
+client = InfluxDB2::Client.new('https://localhost:9999', 'my-token',
                               bucket: 'my-bucket',
                               org: 'my-org',
-                              precision: InfluxDB::WritePrecision::NANOSECOND)
+                              precision: InfluxDB2::WritePrecision::NANOSECOND)
 ```
 
 Configure precision per write:
 ```ruby
-client = InfluxDB::Client.new('https://localhost:9999', 'my-token',
+client = InfluxDB2::Client.new('https://localhost:9999', 'my-token',
                                   bucket: 'my-bucket',
                                   org: 'my-org')
 
 write_api = client.create_write_api
-write_api.write(data: 'h2o,location=west value=33i 15', precision: InfluxDB::WritePrecision::SECOND)
+write_api.write(data: 'h2o,location=west value=33i 15', precision: InfluxDB2::WritePrecision::SECOND)
 ```
 
 Allowed values for precision are:
@@ -97,7 +98,7 @@ Allowed values for precision are:
 
 Default `bucket` and `organization` destination are configured via `InfluxDB::Client`:
 ```ruby
-client = InfluxDB::Client.new('https://localhost:9999', 'my-token',
+client = InfluxDB2::Client.new('https://localhost:9999', 'my-token',
                               bucket: 'my-bucket',
                               org: 'my-org')
 ```
@@ -105,7 +106,7 @@ client = InfluxDB::Client.new('https://localhost:9999', 'my-token',
 but there is also possibility to override configuration per write:
 
 ```ruby
-client = InfluxDB::Client.new('https://localhost:9999', 'my-token')
+client = InfluxDB2::Client.new('https://localhost:9999', 'my-token')
 
 write_api = client.create_write_api
 write_api.write(data: 'h2o,location=west value=33i 15', bucket: 'production-data', org: 'customer-1')
@@ -121,12 +122,12 @@ The data could be written as:
 1. `Array` of above items
 
 ```ruby
-client = InfluxDB::Client.new('https://localhost:9999', 'my-token',
+client = InfluxDB2::Client.new('https://localhost:9999', 'my-token',
                               bucket: 'my-bucket',
                               org: 'my-org',
-                              precision: InfluxDB::WritePrecision::NANOSECOND)
+                              precision: InfluxDB2::WritePrecision::NANOSECOND)
 
-point = InfluxDB::Point.new(name: 'h2o')
+point = InfluxDB2::Point.new(name: 'h2o')
                        .add_tag('location', 'europe')
                        .add_field('level', 2)
 

data/bin/influxdb-restart.sh

@@ -26,9 +26,11 @@ set -e
 DEFAULT_DOCKER_REGISTRY="quay.io/influxdb/"
 DOCKER_REGISTRY="${DOCKER_REGISTRY:-$DEFAULT_DOCKER_REGISTRY}"
 
-DEFAULT_INFLUXDB_V2_VERSION="nightly"
+DEFAULT_INFLUXDB_V2_REPOSITORY="influxdb"
+DEFAULT_INFLUXDB_V2_VERSION="2.0.0-beta"
+INFLUXDB_V2_REPOSITORY="${INFLUXDB_V2_REPOSITORY:-$DEFAULT_INFLUXDB_V2_REPOSITORY}"
 INFLUXDB_V2_VERSION="${INFLUXDB_V2_VERSION:-$DEFAULT_INFLUXDB_V2_VERSION}"
-INFLUXDB_V2_IMAGE=${DOCKER_REGISTRY}influx:${INFLUXDB_V2_VERSION}
+INFLUXDB_V2_IMAGE=${DOCKER_REGISTRY}${INFLUXDB_V2_REPOSITORY}:${INFLUXDB_V2_VERSION}
 
 SCRIPT_PATH="$( cd "$(dirname "$0")" ; pwd -P )"
 

data/influxdb-client.gemspec

@@ -20,11 +20,11 @@
 
 lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'influxdb/client/version'
+require 'influxdb2/client/version'
 
 Gem::Specification.new do |spec|
   spec.name          = 'influxdb-client'
-  spec.version       = ENV['CIRCLE_BUILD_NUM'] ? "#{InfluxDB::VERSION}-#{ENV['CIRCLE_BUILD_NUM']}" : InfluxDB::VERSION
+  spec.version       = ENV['CIRCLE_BUILD_NUM'] ? "#{InfluxDB2::VERSION}-#{ENV['CIRCLE_BUILD_NUM']}" : InfluxDB2::VERSION
   spec.authors       = ['Jakub Bednar']
   spec.email         = ['jakub.bednar@gmail.com']
 

data/lib/{influxdb → influxdb2}/client.rb

@@ -18,8 +18,8 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'influxdb/client/version'
-require 'influxdb/client/client'
-require 'influxdb/client/influx_error'
-require 'influxdb/client/write_api'
-require 'influxdb/client/point'
+require 'influxdb2/client/version'
+require 'influxdb2/client/client'
+require 'influxdb2/client/influx_error'
+require 'influxdb2/client/write_api'
+require 'influxdb2/client/point'

data/lib/{influxdb → influxdb2}/client/client.rb

@@ -17,8 +17,9 @@
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
+require 'net/http'
 
-module InfluxDB
+module InfluxDB2
   # The client is the entry point to HTTP API defined
   # in https://github.com/influxdata/influxdb/blob/master/http/swagger.yml.
   class Client

data/lib/{influxdb → influxdb2}/client/influx_error.rb

@@ -1,4 +1,4 @@
-module InfluxDB
+module InfluxDB2
   # InfluxError that is raised during HTTP communication.
   class InfluxError < StandardError
     # HTTP status code

data/lib/{influxdb → influxdb2}/client/point.rb

@@ -18,7 +18,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-module InfluxDB
+module InfluxDB2
   DEFAULT_WRITE_PRECISION = WritePrecision::NANOSECOND
   ESCAPE_KEY_LIST = ['\\'.freeze, ','.freeze, ' '.freeze, '='.freeze].freeze
   ESCAPE_VALUE_LIST = ['\\'.freeze, '"'.freeze].freeze
@@ -197,13 +197,13 @@ module InfluxDB
         nano_seconds = @time.to_i * 1e9
         nano_seconds += @time.tv_nsec
         case @precision || DEFAULT_WRITE_PRECISION
-        when InfluxDB::WritePrecision::MILLISECOND then
+        when InfluxDB2::WritePrecision::MILLISECOND then
           (nano_seconds / 1e6).round
-        when InfluxDB::WritePrecision::SECOND then
+        when InfluxDB2::WritePrecision::SECOND then
           (nano_seconds / 1e9).round
-        when InfluxDB::WritePrecision::MICROSECOND then
+        when InfluxDB2::WritePrecision::MICROSECOND then
           (nano_seconds / 1e3).round
-        when InfluxDB::WritePrecision::NANOSECOND then
+        when InfluxDB2::WritePrecision::NANOSECOND then
           nano_seconds.round
         end
       else

data/lib/{influxdb → influxdb2}/client/version.rb

@@ -18,6 +18,6 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-module InfluxDB
+module InfluxDB2
   VERSION = '1.0.0'.freeze
 end

data/lib/{influxdb → influxdb2}/client/write_api.rb

@@ -18,7 +18,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-module InfluxDB
+module InfluxDB2
   # Precision constants.
   #
   class WritePrecision

data/test/influxdb/client_test.rb

@@ -22,49 +22,49 @@ require 'test_helper'
 
 class ClientTest < Minitest::Test
   def test_defined_version_number
-    refute_nil ::InfluxDB::VERSION
+    refute_nil ::InfluxDB2::VERSION
   end
 
   def test_client_new
-    refute_nil InfluxDB::Client.new('http://localhost:9999', 'my-token')
+    refute_nil InfluxDB2::Client.new('http://localhost:9999', 'my-token')
   end
 
   def test_client_hash
-    client1 = InfluxDB::Client.new('http://localhost:9999', 'my-token')
-    client2 = InfluxDB::Client.new('http://localhost:9999', 'my-token-diff')
+    client1 = InfluxDB2::Client.new('http://localhost:9999', 'my-token')
+    client2 = InfluxDB2::Client.new('http://localhost:9999', 'my-token-diff')
 
     refute_equal client1.hash, client2.hash
     assert_equal client1.hash, client1.hash
   end
 
   def test_client_eq
-    client1 = InfluxDB::Client.new('http://localhost:9999', 'my-token')
-    client2 = InfluxDB::Client.new('http://localhost:9999', 'my-token-diff')
+    client1 = InfluxDB2::Client.new('http://localhost:9999', 'my-token')
+    client2 = InfluxDB2::Client.new('http://localhost:9999', 'my-token-diff')
 
     refute_equal client1, client2
     assert_equal client1, client1
   end
 
   def test_client_options
-    client = InfluxDB::Client.new('http://localhost:9999', 'my-token')
+    client = InfluxDB2::Client.new('http://localhost:9999', 'my-token')
 
     assert_equal 'http://localhost:9999', client.options[:url]
     assert_equal 'my-token', client.options[:token]
   end
 
   def test_close
-    client = InfluxDB::Client.new('http://localhost:9999', 'my-token')
+    client = InfluxDB2::Client.new('http://localhost:9999', 'my-token')
 
     assert_equal true, client.close!
     assert_equal true, client.close!
   end
 
   def test_get_write_api
-    client = InfluxDB::Client.new('http://localhost:9999', 'my-token')
+    client = InfluxDB2::Client.new('http://localhost:9999', 'my-token')
 
     write_api = client.create_write_api
 
     refute_nil write_api
-    assert_instance_of InfluxDB::WriteApi, write_api
+    assert_instance_of InfluxDB2::WriteApi, write_api
   end
 end

data/test/influxdb/point_test.rb

@@ -22,90 +22,90 @@ require 'test_helper'
 
 class PointTest < MiniTest::Test
   def test_to_line_protocol
-    point_args = InfluxDB::Point.new(name: 'h2o',
-                                     tags: { host: 'aws', region: 'us' },
-                                     fields: { level: 5, saturation: '99%' }, time: 123)
+    point_args = InfluxDB2::Point.new(name: 'h2o',
+                                      tags: { host: 'aws', region: 'us' },
+                                      fields: { level: 5, saturation: '99%' }, time: 123)
     assert_equal 'h2o,host=aws,region=us level=5i,saturation="99%" 123', point_args.to_line_protocol
 
-    point_hash = InfluxDB::Point.from_hash(name: 'h2o',
-                                           tags: { host: 'aws', region: 'us' },
-                                           fields: { level: 5, saturation: '99%' }, time: 123)
+    point_hash = InfluxDB2::Point.from_hash(name: 'h2o',
+                                            tags: { host: 'aws', region: 'us' },
+                                            fields: { level: 5, saturation: '99%' }, time: 123)
     assert_equal 'h2o,host=aws,region=us level=5i,saturation="99%" 123', point_hash.to_line_protocol
   end
 
   def test_measurement_escape
-    point = InfluxDB::Point.new(name: 'h2 o', tags: { location: 'europe' }, fields: { level: 2 })
+    point = InfluxDB2::Point.new(name: 'h2 o', tags: { location: 'europe' }, fields: { level: 2 })
     assert_equal 'h2\\ o,location=europe level=2i', point.to_line_protocol
 
-    point = InfluxDB::Point.new(name: 'h2,o', tags: { location: 'europe' }, fields: { level: 2 })
+    point = InfluxDB2::Point.new(name: 'h2,o', tags: { location: 'europe' }, fields: { level: 2 })
     assert_equal 'h2\\,o,location=europe level=2i', point.to_line_protocol
   end
 
   def test_tag_empty_key
-    point = InfluxDB::Point.new(name: 'h2o', fields: { level: 2 }).add_tag('location', 'europe').add_tag('', 'warn')
+    point = InfluxDB2::Point.new(name: 'h2o', fields: { level: 2 }).add_tag('location', 'europe').add_tag('', 'warn')
 
     assert_equal 'h2o,location=europe level=2i', point.to_line_protocol
   end
 
   def test_tag_empty_value
-    point = InfluxDB::Point.new(name: 'h2o', fields: { level: 2 }).add_tag('location', 'europe').add_tag('log', '')
+    point = InfluxDB2::Point.new(name: 'h2o', fields: { level: 2 }).add_tag('location', 'europe').add_tag('log', '')
 
     assert_equal 'h2o,location=europe level=2i', point.to_line_protocol
   end
 
   def test_override_tag_and_field
-    point = InfluxDB::Point.new(name: 'h2o', fields: { level: '1' })
-                           .add_tag('location', 'europe')
-                           .add_tag('location', 'europe2')
-                           .add_field(:level, 2)
-                           .add_field(:level, 3)
+    point = InfluxDB2::Point.new(name: 'h2o', fields: { level: '1' })
+                            .add_tag('location', 'europe')
+                            .add_tag('location', 'europe2')
+                            .add_field(:level, 2)
+                            .add_field(:level, 3)
 
     assert_equal 'h2o,location=europe2 level=3i', point.to_line_protocol
   end
 
   def test_field_types
-    point = InfluxDB::Point.new(name: 'h2o')
-                           .add_tag('tag_b', 'b')
-                           .add_tag('tag_a', 'a')
-                           .add_field('n1', -2)
-                           .add_field('n2', 10)
-                           .add_field('n3', 1_265_437_718_438_866_624_512)
-                           .add_field('n4', 5.5)
-                           .add_field('bool', true)
-                           .add_field('string', 'string value')
+    point = InfluxDB2::Point.new(name: 'h2o')
+                            .add_tag('tag_b', 'b')
+                            .add_tag('tag_a', 'a')
+                            .add_field('n1', -2)
+                            .add_field('n2', 10)
+                            .add_field('n3', 1_265_437_718_438_866_624_512)
+                            .add_field('n4', 5.5)
+                            .add_field('bool', true)
+                            .add_field('string', 'string value')
 
     expected = 'h2o,tag_a=a,tag_b=b bool=true,n1=-2i,n2=10i,n3=1265437718438866624512i,n4=5.5,string="string value"'
     assert_equal expected, point.to_line_protocol
   end
 
   def test_field_null_value
-    point = InfluxDB::Point.new(name: 'h2o')
-                           .add_tag('location', 'europe')
-                           .add_field('level', 2)
-                           .add_field('warning', nil)
+    point = InfluxDB2::Point.new(name: 'h2o')
+                            .add_tag('location', 'europe')
+                            .add_field('level', 2)
+                            .add_field('warning', nil)
 
     assert_equal 'h2o,location=europe level=2i', point.to_line_protocol
   end
 
   def test_field_escape
-    point = InfluxDB::Point.new(name: 'h2o')
-                           .add_tag('location', 'europe')
-                           .add_field('level', 'string esc\\ape value')
+    point = InfluxDB2::Point.new(name: 'h2o')
+                            .add_tag('location', 'europe')
+                            .add_field('level', 'string esc\\ape value')
 
     assert_equal 'h2o,location=europe level="string esc\\\\ape value"', point.to_line_protocol
 
-    point = InfluxDB::Point.new(name: 'h2o')
-                           .add_tag('location', 'europe')
-                           .add_field('level', 'string esc"ape value')
+    point = InfluxDB2::Point.new(name: 'h2o')
+                            .add_tag('location', 'europe')
+                            .add_field('level', 'string esc"ape value')
 
     assert_equal 'h2o,location=europe level="string esc\"ape value"', point.to_line_protocol
   end
 
   def test_time
-    point = InfluxDB::Point.new(name: 'h2o')
-                           .add_tag('location', 'europe')
-                           .add_field('level', 2)
-                           .time(123, InfluxDB::WritePrecision::NANOSECOND)
+    point = InfluxDB2::Point.new(name: 'h2o')
+                            .add_tag('location', 'europe')
+                            .add_field('level', 2)
+                            .time(123, InfluxDB2::WritePrecision::NANOSECOND)
 
     assert_equal 'h2o,location=europe level=2i 123', point.to_line_protocol
   end
@@ -113,31 +113,31 @@ class PointTest < MiniTest::Test
   def test_time_formatting
     time = Time.utc(2015, 10, 15, 8, 20, 15)
 
-    point = InfluxDB::Point.new(name: 'h2o')
-                           .add_tag('location', 'europe')
-                           .add_field('level', 2)
-                           .time(time, InfluxDB::WritePrecision::MILLISECOND)
+    point = InfluxDB2::Point.new(name: 'h2o')
+                            .add_tag('location', 'europe')
+                            .add_field('level', 2)
+                            .time(time, InfluxDB2::WritePrecision::MILLISECOND)
 
     assert_equal 'h2o,location=europe level=2i 1444897215000', point.to_line_protocol
 
-    point = InfluxDB::Point.new(name: 'h2o')
-                           .add_tag('location', 'europe')
-                           .add_field('level', 2)
-                           .time(time, InfluxDB::WritePrecision::SECOND)
+    point = InfluxDB2::Point.new(name: 'h2o')
+                            .add_tag('location', 'europe')
+                            .add_field('level', 2)
+                            .time(time, InfluxDB2::WritePrecision::SECOND)
 
     assert_equal 'h2o,location=europe level=2i 1444897215', point.to_line_protocol
 
-    point = InfluxDB::Point.new(name: 'h2o')
-                           .add_tag('location', 'europe')
-                           .add_field('level', 2)
-                           .time(time, InfluxDB::WritePrecision::MICROSECOND)
+    point = InfluxDB2::Point.new(name: 'h2o')
+                            .add_tag('location', 'europe')
+                            .add_field('level', 2)
+                            .time(time, InfluxDB2::WritePrecision::MICROSECOND)
 
     assert_equal 'h2o,location=europe level=2i 1444897215000000', point.to_line_protocol
 
-    point = InfluxDB::Point.new(name: 'h2o')
-                           .add_tag('location', 'europe')
-                           .add_field('level', 2)
-                           .time(time, InfluxDB::WritePrecision::NANOSECOND)
+    point = InfluxDB2::Point.new(name: 'h2o')
+                            .add_tag('location', 'europe')
+                            .add_field('level', 2)
+                            .time(time, InfluxDB2::WritePrecision::NANOSECOND)
 
     assert_equal 'h2o,location=europe level=2i 1444897215000000000', point.to_line_protocol
   end
@@ -145,76 +145,76 @@ class PointTest < MiniTest::Test
   def test_time_formatting_default
     time = Time.utc(2015, 10, 15, 8, 20, 15)
 
-    point = InfluxDB::Point.new(name: 'h2o', time: time)
-                           .add_tag('location', 'europe')
-                           .add_field('level', 2)
+    point = InfluxDB2::Point.new(name: 'h2o', time: time)
+                            .add_tag('location', 'europe')
+                            .add_field('level', 2)
 
     assert_equal 'h2o,location=europe level=2i 1444897215000000000', point.to_line_protocol
 
-    point = InfluxDB::Point.new(name: 'h2o')
-                           .add_tag('location', 'europe')
-                           .add_field('level', 2)
-                           .time(time, nil)
+    point = InfluxDB2::Point.new(name: 'h2o')
+                            .add_tag('location', 'europe')
+                            .add_field('level', 2)
+                            .time(time, nil)
 
     assert_equal 'h2o,location=europe level=2i 1444897215000000000', point.to_line_protocol
   end
 
   def test_time_string
-    point_args = InfluxDB::Point.new(name: 'h2o',
-                                     tags: { host: 'aws', region: 'us' },
-                                     fields: { level: 5 }, time: '123')
+    point_args = InfluxDB2::Point.new(name: 'h2o',
+                                      tags: { host: 'aws', region: 'us' },
+                                      fields: { level: 5 }, time: '123')
 
     assert_equal 'h2o,host=aws,region=us level=5i 123', point_args.to_line_protocol
   end
 
   def test_time_float
-    point_args = InfluxDB::Point.new(name: 'h2o',
-                                     tags: { host: 'aws', region: 'us' },
-                                     fields: { level: 5 }, time: 1.444897215e+18)
+    point_args = InfluxDB2::Point.new(name: 'h2o',
+                                      tags: { host: 'aws', region: 'us' },
+                                      fields: { level: 5 }, time: 1.444897215e+18)
 
     assert_equal 'h2o,host=aws,region=us level=5i 1444897215000000000', point_args.to_line_protocol
 
-    point_args = InfluxDB::Point.new(name: 'h2o',
-                                     tags: { host: 'aws', region: 'us' },
-                                     fields: { level: 5 }, time: 102_030_405_060)
+    point_args = InfluxDB2::Point.new(name: 'h2o',
+                                      tags: { host: 'aws', region: 'us' },
+                                      fields: { level: 5 }, time: 102_030_405_060)
 
     assert_equal 'h2o,host=aws,region=us level=5i 102030405060', point_args.to_line_protocol
   end
 
   def test_utf_8
-    point = InfluxDB::Point.new(name: 'h2o')
-                           .add_tag('location', 'Přerov')
-                           .add_field('level', 2)
-                           .time(123, InfluxDB::WritePrecision::NANOSECOND)
+    point = InfluxDB2::Point.new(name: 'h2o')
+                            .add_tag('location', 'Přerov')
+                            .add_field('level', 2)
+                            .time(123, InfluxDB2::WritePrecision::NANOSECOND)
 
     assert_equal 'h2o,location=Přerov level=2i 123', point.to_line_protocol
   end
 
   def test_infinity_values
-    point = InfluxDB::Point.new(name: 'h2o')
-                           .add_tag('location', 'europe')
-                           .add_field('infinity_constant', Float::INFINITY)
-                           .add_field('infinity_positive', 1 / 0.0)
-                           .add_field('infinity_negative', -1 / 0.0)
-                           .add_field('level', 2)
+    point = InfluxDB2::Point.new(name: 'h2o')
+                            .add_tag('location', 'europe')
+                            .add_field('infinity_constant', Float::INFINITY)
+                            .add_field('infinity_positive', 1 / 0.0)
+                            .add_field('infinity_negative', -1 / 0.0)
+                            .add_field('level', 2)
 
     assert_equal 'h2o,location=europe level=2i', point.to_line_protocol
   end
 
   def test_only_infinity_values
-    point = InfluxDB::Point.new(name: 'h2o')
-                           .add_tag('location', 'europe')
-                           .add_field('infinity_constant', Float::INFINITY)
-                           .add_field('infinity_positive', 1 / 0.0)
-                           .add_field('infinity_negative', -1 / 0.0)
+    point = InfluxDB2::Point.new(name: 'h2o')
+                            .add_tag('location', 'europe')
+                            .add_field('infinity_constant', Float::INFINITY)
+                            .add_field('infinity_positive', 1 / 0.0)
+                            .add_field('infinity_negative', -1 / 0.0)
 
     assert_nil point.to_line_protocol
   end
 
   def test_without_tags
-    point = InfluxDB::Point.new(name: 'h2o')
-                           .add_field('level', 2)
-                           .time(123, InfluxDB::WritePrecision::NANOSECOND)
+    point = InfluxDB2::Point.new(name: 'h2o')
+                            .add_field('level', 2)
+                            .time(123, InfluxDB2::WritePrecision::NANOSECOND)
 
     assert_equal 'h2o level=2i 123', point.to_line_protocol
   end

data/test/influxdb/write_api_integration_test.rb

@@ -27,19 +27,19 @@ class WriteApiIntegrationTest < MiniTest::Test
   end
 
   def test_write_into_influx_db
-    client = InfluxDB::Client.new('http://localhost:9999', 'my-token',
-                                  bucket: 'my-bucket',
-                                  org: 'my-org',
-                                  precision: InfluxDB::WritePrecision::NANOSECOND,
-                                  use_ssl: false)
+    client = InfluxDB2::Client.new('http://localhost:9999', 'my-token',
+                                   bucket: 'my-bucket',
+                                   org: 'my-org',
+                                   precision: InfluxDB2::WritePrecision::NANOSECOND,
+                                   use_ssl: false)
 
     now = Time.now.utc
 
     measurement = 'h2o_' + now.to_i.to_s
-    point = InfluxDB::Point.new(name: measurement)
-                           .add_tag('location', 'europe')
-                           .add_field('level', 2)
-                           .time(now, InfluxDB::WritePrecision::NANOSECOND)
+    point = InfluxDB2::Point.new(name: measurement)
+                            .add_tag('location', 'europe')
+                            .add_field('level', 2)
+                            .time(now, InfluxDB2::WritePrecision::NANOSECOND)
 
     client.create_write_api.write(data: point)
 

data/test/influxdb/write_api_test.rb

@@ -26,7 +26,7 @@ class WriteApiTest < MiniTest::Test
   end
 
   def test_required_arguments
-    client = InfluxDB::Client.new('http://localhost:9999', 'my-token')
+    client = InfluxDB2::Client.new('http://localhost:9999', 'my-token')
     write_api = client.create_write_api
 
     # precision
@@ -35,19 +35,19 @@ class WriteApiTest < MiniTest::Test
     end
     # bucket
     assert_raises ArgumentError do
-      write_api.write(data: {}, org: 'my-org', precision: InfluxDB::WritePrecision::NANOSECOND)
+      write_api.write(data: {}, org: 'my-org', precision: InfluxDB2::WritePrecision::NANOSECOND)
     end
     # org
     assert_raises ArgumentError do
-      write_api.write(data: {}, bucket: 'my-bucket', precision: InfluxDB::WritePrecision::NANOSECOND)
+      write_api.write(data: {}, bucket: 'my-bucket', precision: InfluxDB2::WritePrecision::NANOSECOND)
     end
   end
 
   def test_default_arguments_
-    client = InfluxDB::Client.new('http://localhost:9999', 'my-token',
-                                  bucket: 'my-bucket',
-                                  org: 'my-org',
-                                  precision: InfluxDB::WritePrecision::NANOSECOND)
+    client = InfluxDB2::Client.new('http://localhost:9999', 'my-token',
+                                   bucket: 'my-bucket',
+                                   org: 'my-org',
+                                   precision: InfluxDB2::WritePrecision::NANOSECOND)
     write_api = client.create_write_api
 
     # without argument errors
@@ -57,11 +57,11 @@ class WriteApiTest < MiniTest::Test
   def test_write_line_protocol
     stub_request(:any, 'http://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
       .to_return(status: 204)
-    client = InfluxDB::Client.new('http://localhost:9999', 'my-token',
-                                  bucket: 'my-bucket',
-                                  org: 'my-org',
-                                  precision: InfluxDB::WritePrecision::NANOSECOND,
-                                  use_ssl: false)
+    client = InfluxDB2::Client.new('http://localhost:9999', 'my-token',
+                                   bucket: 'my-bucket',
+                                   org: 'my-org',
+                                   precision: InfluxDB2::WritePrecision::NANOSECOND,
+                                   use_ssl: false)
 
     client.create_write_api.write(data: 'h2o,location=west value=33i 15')
 
@@ -72,13 +72,13 @@ class WriteApiTest < MiniTest::Test
   def test_write_point
     stub_request(:any, 'http://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
       .to_return(status: 204)
-    client = InfluxDB::Client.new('http://localhost:9999', 'my-token',
-                                  bucket: 'my-bucket',
-                                  org: 'my-org',
-                                  precision: InfluxDB::WritePrecision::NANOSECOND,
-                                  use_ssl: false)
+    client = InfluxDB2::Client.new('http://localhost:9999', 'my-token',
+                                   bucket: 'my-bucket',
+                                   org: 'my-org',
+                                   precision: InfluxDB2::WritePrecision::NANOSECOND,
+                                   use_ssl: false)
 
-    client.create_write_api.write(data: InfluxDB::Point.new(name: 'h2o')
+    client.create_write_api.write(data: InfluxDB2::Point.new(name: 'h2o')
                                             .add_tag('location', 'europe')
                                             .add_field('level', 2))
 
@@ -89,11 +89,11 @@ class WriteApiTest < MiniTest::Test
   def test_write_hash
     stub_request(:any, 'http://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
       .to_return(status: 204)
-    client = InfluxDB::Client.new('http://localhost:9999', 'my-token',
-                                  bucket: 'my-bucket',
-                                  org: 'my-org',
-                                  precision: InfluxDB::WritePrecision::NANOSECOND,
-                                  use_ssl: false)
+    client = InfluxDB2::Client.new('http://localhost:9999', 'my-token',
+                                   bucket: 'my-bucket',
+                                   org: 'my-org',
+                                   precision: InfluxDB2::WritePrecision::NANOSECOND,
+                                   use_ssl: false)
 
     client.create_write_api.write(data: { name: 'h2o',
                                           tags: { host: 'aws', region: 'us' },
@@ -107,15 +107,15 @@ class WriteApiTest < MiniTest::Test
   def test_write_collection
     stub_request(:any, 'http://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
       .to_return(status: 204)
-    client = InfluxDB::Client.new('http://localhost:9999', 'my-token',
-                                  bucket: 'my-bucket',
-                                  org: 'my-org',
-                                  precision: InfluxDB::WritePrecision::NANOSECOND,
-                                  use_ssl: false)
+    client = InfluxDB2::Client.new('http://localhost:9999', 'my-token',
+                                   bucket: 'my-bucket',
+                                   org: 'my-org',
+                                   precision: InfluxDB2::WritePrecision::NANOSECOND,
+                                   use_ssl: false)
 
-    point = InfluxDB::Point.new(name: 'h2o')
-                           .add_tag('location', 'europe')
-                           .add_field('level', 2)
+    point = InfluxDB2::Point.new(name: 'h2o')
+                            .add_tag('location', 'europe')
+                            .add_field('level', 2)
 
     hash = { name: 'h2o',
              tags: { host: 'aws', region: 'us' },
@@ -132,11 +132,11 @@ class WriteApiTest < MiniTest::Test
   def test_authorization_header
     stub_request(:any, 'http://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
       .to_return(status: 204)
-    client = InfluxDB::Client.new('http://localhost:9999', 'my-token',
-                                  bucket: 'my-bucket',
-                                  org: 'my-org',
-                                  precision: InfluxDB::WritePrecision::NANOSECOND,
-                                  use_ssl: false)
+    client = InfluxDB2::Client.new('http://localhost:9999', 'my-token',
+                                   bucket: 'my-bucket',
+                                   org: 'my-org',
+                                   precision: InfluxDB2::WritePrecision::NANOSECOND,
+                                   use_ssl: false)
 
     client.create_write_api.write(data: 'h2o,location=west value=33i 15')
 
@@ -147,10 +147,10 @@ class WriteApiTest < MiniTest::Test
   def test_without_data
     stub_request(:any, 'http://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
       .to_return(status: 204)
-    client = InfluxDB::Client.new('http://localhost:9999', 'my-token',
-                                  bucket: 'my-bucket',
-                                  org: 'my-org',
-                                  precision: InfluxDB::WritePrecision::NANOSECOND)
+    client = InfluxDB2::Client.new('http://localhost:9999', 'my-token',
+                                   bucket: 'my-bucket',
+                                   org: 'my-org',
+                                   precision: InfluxDB2::WritePrecision::NANOSECOND)
 
     client.create_write_api.write(data: '')
 
@@ -164,13 +164,13 @@ class WriteApiTest < MiniTest::Test
     stub_request(:any, 'http://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
       .to_return(status: 400, headers: { 'X-Platform-Error-Code' => 'invalid' }, body: error_body)
 
-    client = InfluxDB::Client.new('http://localhost:9999', 'my-token',
-                                  bucket: 'my-bucket',
-                                  org: 'my-org',
-                                  precision: InfluxDB::WritePrecision::NANOSECOND,
-                                  use_ssl: false)
+    client = InfluxDB2::Client.new('http://localhost:9999', 'my-token',
+                                   bucket: 'my-bucket',
+                                   org: 'my-org',
+                                   precision: InfluxDB2::WritePrecision::NANOSECOND,
+                                   use_ssl: false)
 
-    error = assert_raises InfluxDB::InfluxError do
+    error = assert_raises InfluxDB2::InfluxError do
       client.create_write_api.write(data: 'h2o,location=west value=33i 15')
     end
 
@@ -187,11 +187,11 @@ class WriteApiTest < MiniTest::Test
     stub_request(:any, 'http://localhost:9090/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
       .to_return(status: 204)
 
-    client = InfluxDB::Client.new('http://localhost:9999', 'my-token',
-                                  bucket: 'my-bucket',
-                                  org: 'my-org',
-                                  precision: InfluxDB::WritePrecision::NANOSECOND,
-                                  use_ssl: false)
+    client = InfluxDB2::Client.new('http://localhost:9999', 'my-token',
+                                   bucket: 'my-bucket',
+                                   org: 'my-org',
+                                   precision: InfluxDB2::WritePrecision::NANOSECOND,
+                                   use_ssl: false)
 
     client.create_write_api.write(data: 'h2o,location=west value=33i 15')
 
@@ -206,14 +206,14 @@ class WriteApiTest < MiniTest::Test
       .to_return(status: 307, headers:
           { 'location' => 'http://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns' })
 
-    client = InfluxDB::Client.new('http://localhost:9999', 'my-token',
-                                  bucket: 'my-bucket',
-                                  org: 'my-org',
-                                  precision: InfluxDB::WritePrecision::NANOSECOND,
-                                  max_redirect_count: 5,
-                                  use_ssl: false)
+    client = InfluxDB2::Client.new('http://localhost:9999', 'my-token',
+                                   bucket: 'my-bucket',
+                                   org: 'my-org',
+                                   precision: InfluxDB2::WritePrecision::NANOSECOND,
+                                   max_redirect_count: 5,
+                                   use_ssl: false)
 
-    error = assert_raises InfluxDB::InfluxError do
+    error = assert_raises InfluxDB2::InfluxError do
       client.create_write_api.write(data: 'h2o,location=west value=33i 15')
     end
 
@@ -221,13 +221,13 @@ class WriteApiTest < MiniTest::Test
   end
 
   def test_write_precision_constant
-    assert_equal InfluxDB::WritePrecision::SECOND, InfluxDB::WritePrecision.new.get_from_value('s')
-    assert_equal InfluxDB::WritePrecision::MILLISECOND, InfluxDB::WritePrecision.new.get_from_value('ms')
-    assert_equal InfluxDB::WritePrecision::MICROSECOND, InfluxDB::WritePrecision.new.get_from_value('us')
-    assert_equal InfluxDB::WritePrecision::NANOSECOND, InfluxDB::WritePrecision.new.get_from_value('ns')
+    assert_equal InfluxDB2::WritePrecision::SECOND, InfluxDB2::WritePrecision.new.get_from_value('s')
+    assert_equal InfluxDB2::WritePrecision::MILLISECOND, InfluxDB2::WritePrecision.new.get_from_value('ms')
+    assert_equal InfluxDB2::WritePrecision::MICROSECOND, InfluxDB2::WritePrecision.new.get_from_value('us')
+    assert_equal InfluxDB2::WritePrecision::NANOSECOND, InfluxDB2::WritePrecision.new.get_from_value('ns')
 
     error = assert_raises RuntimeError do
-      InfluxDB::WritePrecision.new.get_from_value('not_supported')
+      InfluxDB2::WritePrecision.new.get_from_value('not_supported')
     end
 
     assert_equal 'The time precision not_supported is not supported.', error.message

data/test/test_helper.rb

@@ -27,7 +27,7 @@ if ENV['CI'] == 'true'
 end
 
 $LOAD_PATH.unshift File.expand_path('../lib', __dir__)
-require 'influxdb/client'
+require 'influxdb2/client'
 
 require 'minitest/autorun'
 require 'minitest/reporters'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: influxdb-client
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre.121
+  version: 1.0.0.pre.159
 platform: ruby
 authors:
 - Jakub Bednar
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-08 00:00:00.000000000 Z
+date: 2020-01-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -142,12 +142,12 @@ files:
 - bin/influxdb-onboarding.sh
 - bin/influxdb-restart.sh
 - influxdb-client.gemspec
-- lib/influxdb/client.rb
-- lib/influxdb/client/client.rb
-- lib/influxdb/client/influx_error.rb
-- lib/influxdb/client/point.rb
-- lib/influxdb/client/version.rb
-- lib/influxdb/client/write_api.rb
+- lib/influxdb2/client.rb
+- lib/influxdb2/client/client.rb
+- lib/influxdb2/client/influx_error.rb
+- lib/influxdb2/client/point.rb
+- lib/influxdb2/client/version.rb
+- lib/influxdb2/client/write_api.rb
 - test/influxdb/client_test.rb
 - test/influxdb/point_test.rb
 - test/influxdb/write_api_integration_test.rb