influxdb 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 48b3b597ccffb495aafb01038b0a00300a5aaf85
-  data.tar.gz: ae802e95ce9675869e5ae482d30d6a46ed7318ac
+  metadata.gz: 91c31bce05c5e0a514a22cef9375f6f51e1f7e3d
+  data.tar.gz: 842b0127d866fb9ed3a3cf0e7d3b878c6d1c5d01
 SHA512:
-  metadata.gz: 9725f16e1b6cf6b15dfab0b0717a30fff9a1eca6dc7b1b7463adf5a985745ff83c14e90191aa58a06167b6be7bc3e085a79424ce303d78172ef8e7f513816f43
-  data.tar.gz: 6875eff543b72a4791fd8d7e73b0ceef5a079983dfee1356d758ad43a900d88f77f86bbdb3a0d9d789eeceaab576203a015e83e5ae09ad5ebda2ece3fb2fcfc3
+  metadata.gz: c3f979934171092ad2c2b3c5ff6041cd40663e55d87eaedc8473951097bb1f28d2089acf3448a8dda86e25e521f7ed606314eeb0a9399492a9427c35f39aaebf
+  data.tar.gz: 71d9c02ef46b61c64b6357e2df5886f1cc68517cbdf76da11104223535cb76dc88b73ffa671ad5a83d5afb344c99621c7b46df9d4462461364808f1f7c39810a

data/README.md

@@ -194,6 +194,17 @@ name = '1h.cpu'
 influxdb.delete_retention_policy(name, database)
 ```
 
+Alter a retention policy for a database:
+
+``` ruby
+database = 'foo'
+name = '1h.cpu'
+duration = '10m'
+replication = 2
+
+influxdb.alter_retention_policy(name, database, duration, replication)
+```
+
 Write some data:
 
 ``` ruby
@@ -226,10 +237,10 @@ Write data with time precision (precision can be set in 2 ways):
 ``` ruby
 require 'influxdb'
 
-username = 'foo'
-password = 'bar'
-database = 'site_development'
-name     = 'foobar'
+username       = 'foo'
+password       = 'bar'
+database       = 'site_development'
+name           = 'foobar'
 time_precision = 's'
 
 # either in the client initialization:
@@ -249,6 +260,31 @@ influxdb.write_point(name, data, time_precision)
 
 ```
 
+Write data with a specific retention policy:
+
+``` ruby
+require 'influxdb'
+
+username  = 'foo'
+password  = 'bar'
+database  = 'site_development'
+name      = 'foobar'
+precision = 's'
+retention = '1h.cpu'
+
+influxdb = InfluxDB::Client.new database,
+                                username: username,
+                                password: password
+
+data = {
+  values: { value: 0 },
+  tags: { foo: 'bar', bar: 'baz' }
+  timestamp: Time.now.to_i
+}
+
+influxdb.write_point(name, data, precision, retention)
+```
+
 Write multiple points in a batch (performance boost):
 
 ``` ruby
@@ -274,7 +310,29 @@ influxdb.write_points(data, precision)
 
 ```
 
-Write asynchronously:
+Write multiple points in a batch with a specific retention policy:
+
+``` ruby
+
+data = [
+  {
+    series: 'cpu',
+    tags: { host: 'server_1', regios: 'us' },
+    values: {internal: 5, external: 0.453345}
+  },
+  {
+    series: 'gpu',
+    values: {value: 0.9999},
+  }
+]
+
+precision = 'm'
+retention = '1h.cpu'
+influxdb.write_points(data, precision, retention)
+
+```
+
+Write asynchronously (note that a retention policy cannot be specified for asynchronous writes):
 
 ``` ruby
 require 'influxdb'
@@ -283,7 +341,6 @@ username = 'foo'
 password = 'bar'
 database = 'site_development'
 name     = 'foobar'
-time_precision = 's'
 
 influxdb = InfluxDB::Client.new database,
                                 username: username,
@@ -299,7 +356,7 @@ data = {
 influxdb.write_point(name, data)
 ```
 
-Write data via UDP:
+Write data via UDP (note that a retention policy cannot be specified for UDP writes):
 
 ``` ruby
 require 'influxdb'
@@ -333,8 +390,8 @@ influxdb = InfluxDB::Client.new database,
 influxdb.query 'select * from time_series_1' # results are grouped by name, but also their tags
 
 # result:
-[{"name"=>"time_series_1", "tags"=>{"region"=>"uk"}, "values"=>[{"time"=>"2015-07-09T09:03:31Z", "count"=>32, "value"=>0.9673}, {"time"=>"2015-07-09T09:03:49Z", "count"=>122, "value"=>0.4444}]},
- {"name"=>"time_series_1", "tags"=>{"region"=>"us"}, "values"=>[{"time"=>"2015-07-09T09:02:54Z", "count"=>55, "value"=>0.4343}]}]
+# [{"name"=>"time_series_1", "tags"=>{"region"=>"uk"}, "values"=>[{"time"=>"2015-07-09T09:03:31Z", "count"=>32, "value"=>0.9673}, {"time"=>"2015-07-09T09:03:49Z", "count"=>122, "value"=>0.4444}]},
+# {"name"=>"time_series_1", "tags"=>{"region"=>"us"}, "values"=>[{"time"=>"2015-07-09T09:02:54Z", "count"=>55, "value"=>0.4343}]}]
 
 # with a block:
 influxdb.query 'select * from time_series_1' do |name, tags, points|
@@ -346,6 +403,22 @@ end
 # time_series_1 [ {"region"=>"us"} ] => [{"time"=>"2015-07-09T09:02:54Z", "count"=>55, "value"=>0.4343}]
 ```
 
+If you would rather receive points with integer timestamp, it's possible to set `epoch` parameter:
+
+``` ruby
+# globally, on client initialization:
+influxdb = InfluxDB::Client.new database, epoch: 's'
+
+influxdb.query 'select * from time_series'
+# result:
+# [{"name"=>"time_series", "tags"=>{"region"=>"uk"}, "values"=>[{"time"=>1438411376, "count"=>32, "value"=>0.9673}]}]
+
+# or for a specific query call:
+influxdb.query 'select * from time_series', epoch: 'ms'
+# result:
+# [{"name"=>"time_series", "tags"=>{"region"=>"uk"}, "values"=>[{"time"=>1438411376000, "count"=>32, "value"=>0.9673}]}]
+```
+
 By default, InfluxDB::Client will denormalize points (received from InfluxDB as columns and rows), if you want to get _raw_ data add `denormalize: false` to initialization options or to query itself:
 
 ``` ruby

data/lib/influxdb/config.rb

@@ -19,7 +19,8 @@ module InfluxDB
                   :read_timeout,
                   :retry,
                   :prefix,
-                  :denormalize
+                  :denormalize,
+                  :epoch
 
     attr_reader :async, :udp
 
@@ -44,6 +45,7 @@ module InfluxDB
       @udp = opts.fetch(:udp, false)
       @retry = opts.fetch(:retry, nil)
       @denormalize = opts.fetch(:denormalize, true)
+      @epoch = opts.fetch(:epoch, false)
       @retry =
         case @retry
         when Integer

data/lib/influxdb/query/core.rb

@@ -8,10 +8,9 @@ module InfluxDB
 
       # rubocop:disable Metrics/MethodLength
       def query(query, opts = {})
-        precision   = opts.fetch(:precision, config.time_precision)
         denormalize = opts.fetch(:denormalize, config.denormalize)
-
-        url = full_url("/query", q: query, db: config.database, precision: precision)
+        params = query_params(query, opts)
+        url = full_url("/query", params)
         series = fetch_series(get(url, parse: true))
 
         if block_given?
@@ -37,27 +36,37 @@ module InfluxDB
       #     values: {value: 0.9999},
       #   }
       # ])
-      def write_points(data, precision = nil)
+      def write_points(data, precision = nil, retention_policy = nil)
         data = data.is_a?(Array) ? data : [data]
         payload = generate_payload(data)
-        writer.write(payload, precision)
+        writer.write(payload, precision, retention_policy)
       end
 
       # Example:
       # write_point('cpu', tags: {region: 'us'}, values: {internal: 60})
-      def write_point(series, data, precision = nil)
-        data.merge!(series: series)
-        write_points(data, precision)
+      def write_point(series, data, precision = nil, retention_policy = nil)
+        write_points(data.merge(series: series), precision, retention_policy)
       end
 
-      def write(data, precision)
+      def write(data, precision, retention_policy = nil)
         precision ||= config.time_precision
-        url = full_url("/write", db: config.database, precision: precision)
+        params      = { db: config.database, precision: precision }
+        params[:rp] = retention_policy if retention_policy
+        url = full_url("/write", params)
         post(url, data)
       end
 
       private
 
+      def query_params(query, opts)
+        precision   = opts.fetch(:precision, config.time_precision)
+        epoch       = opts.fetch(:epoch, config.epoch)
+
+        params = { q: query, db: config.database, precision: precision }
+        params.merge!(epoch: epoch) if epoch
+        params
+      end
+
       def denormalized_series_list(series)
         series.map do |s|
           {

data/lib/influxdb/query/retention_policy.rb

@@ -8,7 +8,7 @@ module InfluxDB
       end
 
       def list_retention_policies(database)
-        resp = execute("SHOW RETENTION POLICIES \"#{database}\"", parse: true)
+        resp = execute("SHOW RETENTION POLICIES ON \"#{database}\"", parse: true)
         data = fetch_series(resp).fetch(0)
 
         data['values'].map do |policy|
@@ -21,6 +21,12 @@ module InfluxDB
       def delete_retention_policy(name, database)
         execute("DROP RETENTION POLICY \"#{name}\" ON #{database}")
       end
+
+      def alter_retention_policy(name, database, duration, replication, default = false)
+        execute(
+          "ALTER RETENTION POLICY \"#{name}\" ON #{database} "\
+          "DURATION #{duration} REPLICATION #{replication}#{default ? ' DEFAULT' : ''}")
+      end
     end
   end
 end

data/lib/influxdb/query/user.rb

@@ -15,11 +15,20 @@ module InfluxDB
         execute("SET PASSWORD FOR #{username} = '#{password}'")
       end
 
+      # permission => [:all]
+      def grant_user_admin_privileges(username)
+        execute("GRANT ALL PRIVILEGES TO #{username}")
+      end
+
       # permission => [:read|:write|:all]
       def grant_user_privileges(username, database, permission)
         execute("GRANT #{permission.to_s.upcase} ON #{database} TO #{username}")
       end
 
+      def list_user_grants(username)
+        execute("SHOW GRANTS FOR #{username}")
+      end
+
       # permission => [:read|:write|:all]
       def revoke_user_privileges(username, database, permission)
         execute("REVOKE #{permission.to_s.upcase} ON #{database} FROM #{username}")

data/lib/influxdb/version.rb

@@ -1,3 +1,3 @@
 module InfluxDB # :nodoc:
-  VERSION = "0.2.2"
+  VERSION = "0.2.3"
 end

data/lib/influxdb/writer/async.rb

@@ -12,7 +12,7 @@ module InfluxDB
         @config = config
       end
 
-      def write(data, _precision = nil)
+      def write(data, _precision = nil, _retention_policy = nil)
         data = data.is_a?(Array) ? data : [data]
         data.map { |p| worker.push(p) }
       end

data/lib/influxdb/writer/udp.rb

@@ -13,7 +13,7 @@ module InfluxDB
         socket.connect(host, port)
       end
 
-      def write(payload, _precision = nil)
+      def write(payload, _precision = nil, _retention_policy = nil)
         socket.send(payload, 0)
       end
     end

data/spec/influxdb/cases/query_retention_policy_spec.rb

@@ -23,7 +23,7 @@ describe InfluxDB::Client do
 
     before do
       stub_request(:get, "http://influxdb.test:9999/query").with(
-        query: { u: "username", p: "password", q: "SHOW RETENTION POLICIES \"database\"" }
+        query: { u: "username", p: "password", q: "SHOW RETENTION POLICIES ON \"database\"" }
       ).to_return(body: JSON.generate(response), status: 200)
     end
 
@@ -81,4 +81,42 @@ describe InfluxDB::Client do
       expect(subject.delete_retention_policy('1h.cpu', 'foo')).to be_a(Net::HTTPOK)
     end
   end
+
+  describe "#alter_retention_policy" do
+    context "default" do
+      before do
+        stub_request(:get, "http://influxdb.test:9999/query")
+          .with(
+            query:
+              {
+                u: "username",
+                p: "password",
+                q: "ALTER RETENTION POLICY \"1h.cpu\" ON foo DURATION 1h REPLICATION 2 DEFAULT"
+              }
+          )
+      end
+
+      it "should GET to alter a new database" do
+        expect(subject.alter_retention_policy('1h.cpu', 'foo', '1h', 2, true)).to be_a(Net::HTTPOK)
+      end
+    end
+
+    context "non-default" do
+      before do
+        stub_request(:get, "http://influxdb.test:9999/query")
+          .with(
+            query:
+              {
+                u: "username",
+                p: "password",
+                q: "ALTER RETENTION POLICY \"1h.cpu\" ON foo DURATION 1h REPLICATION 2"
+              }
+          )
+      end
+
+      it "should GET to alter a new database" do
+        expect(subject.alter_retention_policy('1h.cpu', 'foo', '1h', 2)).to be_a(Net::HTTPOK)
+      end
+    end
+  end
 end

data/spec/influxdb/cases/query_user_spec.rb

@@ -50,6 +50,21 @@ describe InfluxDB::Client do
     end
   end
 
+  describe "#grant_user_admin_privileges" do
+    let(:user) { 'useruser' }
+    let(:query) { "GRANT ALL PRIVILEGES TO #{user}" }
+
+    before do
+      stub_request(:get, "http://influxdb.test:9999/query").with(
+        query: { u: "username", p: "password", q: query }
+      )
+    end
+
+    it "should GET to grant privileges for a user on a database" do
+      expect(subject.grant_user_admin_privileges(user)).to be_a(Net::HTTPOK)
+    end
+  end
+
   describe "#revoke_user_privileges" do
     let(:user) { 'useruser' }
     let(:perm) { :write }
@@ -124,4 +139,19 @@ describe InfluxDB::Client do
       expect(subject.list_users).to eq(expected_result)
     end
   end
+
+  describe "#list_user_grants" do
+    let(:user) { 'useruser' }
+    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 => {})
+    end
+
+    it "should GET for a user" do
+      expect(subject.list_user_grants(user)).to be_a(Net::HTTPOK)
+    end
+  end
 end

data/spec/influxdb/cases/querying_spec.rb

@@ -145,5 +145,38 @@ describe InfluxDB::Client do
         expect(results).to eq(expected_result)
       end
     end
+
+    context "with epoch set to seconds" do
+      let(:args) { {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]] }
+            ]
+          }]
+        }
+      end
+      let(:expected_result) do
+        [{ "name" => "cpu", "tags" => { "region" => "pl" },
+           "values" => [{ "time" => 1438580576, "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 }]
+        }]
+      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
+    end
   end
 end

data/spec/influxdb/cases/write_points_spec.rb

@@ -40,6 +40,13 @@ describe InfluxDB::Client do
     it "should POST to add single point" do
       expect(subject.write_point(series, data)).to be_a(Net::HTTPOK)
     end
+
+    it "should not mutate data object" do
+      original_data = data
+      subject.write_point(series, data)
+      expect(data[:series]).to be_nil
+      expect(original_data).to eql(data)
+    end
   end
 
   describe "#write_points" do
@@ -136,5 +143,35 @@ describe InfluxDB::Client do
         expect(subject.write_points(data, 'm')).to be_a(Net::HTTPOK)
       end
     end
+
+    context "with retention policy" do
+      let(:data) do
+        [{
+          series: 'cpu',
+          values: { temp: 88,  value: 54 }
+        },
+         {
+           series: 'gpu',
+           values: { value: 0.5435345 }
+         }]
+      end
+
+      let(:body) do
+        data.map do |point|
+          InfluxDB::PointValue.new(point).dump
+        end.join("\n")
+      end
+
+      before do
+        stub_request(:post, "http://influxdb.test:9999/write").with(
+          query: { u: "username", p: "password", precision: 's', db: database, rp: 'rp_1_hour' },
+          headers: { "Content-Type" => "application/octet-stream" },
+          body: body
+        )
+      end
+      it "should POST multiple points" do
+        expect(subject.write_points(data, nil, 'rp_1_hour')).to be_a(Net::HTTPOK)
+      end
+    end
   end
 end

data/spec/influxdb/config_spec.rb

@@ -19,6 +19,7 @@ describe InfluxDB::Config do
     specify { expect(conf.denormalize).to be_truthy }
     specify { expect(conf).not_to be_udp }
     specify { expect(conf).not_to be_async }
+    specify { expect(conf.epoch).to be_falsey }
   end
 
   context "with no database specified" do
@@ -38,6 +39,7 @@ describe InfluxDB::Config do
     specify { expect(conf.username).to eq "username" }
     specify { expect(conf.password).to eq "password" }
     specify { expect(conf.time_precision).to eq "m" }
+    specify { expect(conf.epoch).to be_falsey }
   end
 
   context "with both a database and options specified" do
@@ -58,6 +60,7 @@ describe InfluxDB::Config do
     specify { expect(conf.username).to eq "username" }
     specify { expect(conf.password).to eq "password" }
     specify { expect(conf.time_precision).to eq "m" }
+    specify { expect(conf.epoch).to be_falsey }
   end
 
   context "with ssl option specified" do
@@ -115,4 +118,10 @@ describe InfluxDB::Config do
 
     specify { expect(conf).to be_async }
   end
+
+  context "with epoch specified as seconds" do
+    let(:args) { [{ epoch: 's' }] }
+
+    specify { expect(conf.epoch).to eq 's' }
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: influxdb
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - Todd Persen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-29 00:00:00.000000000 Z
+date: 2015-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json