influxdb 0.1.9 → 0.2.0

data/lib/influxdb/query/database.rb

@@ -0,0 +1,21 @@
+module InfluxDB
+  module Query
+    module Database # :nodoc:
+      def create_database(name)
+        execute("CREATE DATABASE #{name}")
+      end
+
+      def delete_database(name)
+        execute("DROP DATABASE #{name}")
+      end
+
+      def list_databases
+        resp = execute("SHOW DATABASES", parse: true)
+        fetch_series(resp).fetch(0, {})
+          .fetch('values', [])
+          .flatten
+          .map { |v| { 'name' => v } }
+      end
+    end
+  end
+end

data/lib/influxdb/query/retention_policy.rb

@@ -0,0 +1,26 @@
+module InfluxDB
+  module Query
+    module RetentionPolicy # :nodoc:
+      def create_retention_policy(name, database, duration, replication, default = false)
+        execute(
+          "CREATE RETENTION POLICY \"#{name}\" ON #{database} "\
+          "DURATION #{duration} REPLICATION #{replication}#{default ? ' DEFAULT' : ''}")
+      end
+
+      def list_retention_policies(database)
+        resp = execute("SHOW RETENTION POLICIES \"#{database}\"", parse: true)
+        data = fetch_series(resp).fetch(0)
+
+        data['values'].map do |policy|
+          policy.each.with_index.inject({}) do |hash, (value, index)|
+            hash.tap { |h| h[data['columns'][index]] = value }
+          end
+        end
+      end
+
+      def delete_retention_policy(name, database)
+        execute("DROP RETENTION POLICY \"#{name}\" ON #{database}")
+      end
+    end
+  end
+end

data/lib/influxdb/query/user.rb

@@ -0,0 +1,41 @@
+module InfluxDB
+  module Query
+    module User # :nodoc:
+      # create_database_user('testdb', 'user', 'pass') - grants all privileges by default
+      # create_database_user('testdb', 'user', 'pass', permissions: :read) - use [:read|:write|:all]
+      def create_database_user(database, username, password, options = {})
+        permissions = options.fetch(:permissions, :all)
+        execute(
+          "CREATE user #{username} WITH PASSWORD '#{password}'; "\
+          "GRANT #{permissions.to_s.upcase} ON #{database} TO #{username}"
+        )
+      end
+
+      def update_user_password(username, password)
+        execute("SET PASSWORD FOR #{username} = '#{password}'")
+      end
+
+      # permission => [:read|:write|:all]
+      def grant_user_privileges(username, database, permission)
+        execute("GRANT #{permission.to_s.upcase} ON #{database} TO #{username}")
+      end
+
+      # permission => [:read|:write|:all]
+      def revoke_user_privileges(username, database, permission)
+        execute("REVOKE #{permission.to_s.upcase} ON #{database} FROM #{username}")
+      end
+
+      def delete_user(username)
+        execute("DROP USER #{username}")
+      end
+
+      # => [{"username"=>"usr", "admin"=>true}, {"username"=>"justauser", "admin"=>false}]
+      def list_users
+        resp = execute("SHOW USERS", parse: true)
+        fetch_series(resp).fetch(0, {})
+          .fetch('values', [])
+          .map { |v| { 'username' => v.first, 'admin' => v.last } }
+      end
+    end
+  end
+end

data/lib/influxdb/version.rb

@@ -1,3 +1,3 @@
-module InfluxDB
-  VERSION = "0.1.9"
+module InfluxDB # :nodoc:
+  VERSION = "0.2.0"
 end

data/lib/influxdb/writer/async.rb

@@ -0,0 +1,115 @@
+require 'thread'
+require "net/http"
+require "uri"
+
+module InfluxDB
+  module Writer # :nodoc: all
+    class Async
+      attr_reader :config, :client
+
+      def initialize(client, config)
+        @client = client
+        @config = config
+      end
+
+      def write(data, _precision = nil)
+        data = data.is_a?(Array) ? data : [data]
+        data.map { |p| worker.push(p) }
+      end
+
+      WORKER_MUTEX = Mutex.new
+      def worker
+        return @worker if @worker
+        WORKER_MUTEX.synchronize do
+          # this return is necessary because the previous mutex holder
+          # might have already assigned the @worker
+          return @worker if @worker
+          @worker = Worker.new(client, config)
+        end
+      end
+
+      class Worker
+        attr_reader :client, :queue, :threads
+
+        include InfluxDB::Logging
+
+        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)
+
+          spawn_threads!
+
+          at_exit do
+            log :debug, "Thread exiting, flushing queue."
+            check_background_queue until queue.empty?
+          end
+        end
+
+        def push(payload)
+          queue.push(payload)
+        end
+
+        def current_threads
+          Thread.list.select { |t| t[:influxdb] == object_id }
+        end
+
+        def current_thread_count
+          Thread.list.count { |t| t[:influxdb] == object_id }
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/MethodLength
+        # rubocop:disable Metrics/AbcSize
+
+        def spawn_threads!
+          @threads = []
+          NUM_WORKER_THREADS.times do |thread_num|
+            log :debug, "Spawning background worker thread #{thread_num}."
+
+            @threads << Thread.new do
+              Thread.current[:influxdb] = object_id
+
+              until client.stopped?
+                check_background_queue(thread_num)
+                sleep rand(SLEEP_INTERVAL)
+              end
+
+              log :debug, "Exit background worker thread #{thread_num}."
+            end
+          end
+        end
+
+        def check_background_queue(thread_num = 0)
+          log :debug,
+              "Checking background queue on thread #{thread_num} (#{current_thread_count} active)"
+
+          loop do
+            data = []
+
+            while data.size < MAX_POST_POINTS && !queue.empty?
+              p = queue.pop(true) rescue next
+              data.push p
+            end
+
+            return if data.empty?
+
+            begin
+              log :debug, "Found data in the queue! (#{data.length} points)"
+              client.write(data)
+            rescue => e
+              puts "Cannot write data: #{e.inspect}"
+            end
+
+            break if queue.length > MAX_POST_POINTS
+          end
+        end
+      end
+    end
+  end
+end

data/lib/influxdb/writer/udp.rb

@@ -0,0 +1,21 @@
+module InfluxDB
+  module Writer
+    # Writes data to InfluxDB through UDP
+    class UDP
+      attr_accessor :socket
+      attr_reader :host, :port
+      def initialize(client, config)
+        @client = client
+        config = config.is_a?(Hash) ? config : {}
+        @host = config.fetch(:host, 'localhost')
+        @port = config.fetch(:port, 4444)
+        self.socket = UDPSocket.new
+        socket.connect(host, port)
+      end
+
+      def write(payload, _precision = nil)
+        socket.send(payload, 0)
+      end
+    end
+  end
+end

data/spec/influxdb/cases/async_client_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+require "timeout"
+
+describe InfluxDB::Client do
+  let(:subject) { described_class.new(async: true) }
+
+  let(:worker_klass) { InfluxDB::Writer::Async::Worker }
+
+  specify { expect(subject.writer).to be_a(InfluxDB::Writer::Async) }
+
+  describe "#write_point" do
+    let(:payload) { "responses,region=eu value=5" }
+
+    it "sends writes to client" do
+      # exact times can be 2 or 3 (because we have 3 worker threads),
+      # but cannot be less than 2 due to MAX_POST_POINTS limit
+      expect(subject).to(receive(:write)).at_least(2).times
+
+      (worker_klass::MAX_POST_POINTS + 100).times do
+        subject.write_point('a', {})
+      end
+
+      Timeout.timeout(2 * worker_klass::SLEEP_INTERVAL) do
+        subject.stop!
+        # ensure threads exit
+        subject.writer.worker.threads.each(&:join)
+
+        # flush queue (we cannot test `at_exit`)
+        subject.writer.worker.check_background_queue
+      end
+    end
+  end
+end

data/spec/influxdb/cases/query_cluster_spec.rb

@@ -0,0 +1,65 @@
+require "spec_helper"
+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)
+    )
+  end
+
+  let(:args) { {} }
+
+  describe "#create_cluster_admin" do
+    let(:user) { 'adminadmin' }
+    let(:pass) { 'passpass' }
+    let(:query) { "CREATE USER #{user} WITH PASSWORD '#{pass}' WITH ALL PRIVILEGES" }
+
+    before do
+      stub_request(:get, "http://influxdb.test:9999/query").with(
+        query: { u: "username", p: "password", q: query }
+      )
+    end
+
+    it "should GET to create a new cluster admin" do
+      expect(subject.create_cluster_admin(user, pass)).to be_a(Net::HTTPOK)
+    end
+  end
+
+  describe "#list_cluster_admins" do
+    let(:response) { { "results" => [{ "series" => [{ "columns" => %w(user admin), "values" => [["dbadmin", true], ["foobar", false]] }] }] } }
+    let(:expected_result) { ["dbadmin"] }
+
+    before do
+      stub_request(:get, "http://influxdb.test:9999/query").with(
+        query: { u: "username", p: "password", q: "SHOW USERS" }
+      ).to_return(body: JSON.generate(response, status: 200))
+    end
+
+    it "should GET a list of cluster admins" do
+      expect(subject.list_cluster_admins).to eq(expected_result)
+    end
+  end
+
+  describe "#revoke_cluster_admin_privileges" do
+    let(:user) { 'useruser' }
+    let(:query) { "REVOKE ALL PRIVILEGES FROM #{user}" }
+
+    before do
+      stub_request(:get, "http://influxdb.test:9999/query").with(
+        query: { u: "username", p: "password", q: query }
+      )
+    end
+
+    it "should GET to revoke cluster admin privileges from a user" do
+      expect(subject.revoke_cluster_admin_privileges(user)).to be_a(Net::HTTPOK)
+    end
+  end
+end

data/spec/influxdb/cases/query_continuous_query_spec.rb

@@ -0,0 +1,82 @@
+require "spec_helper"
+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)
+    )
+  end
+
+  let(:args) { {} }
+
+  describe "#list_continuous_queries" do
+    let(:query) { "SHOW CONTINUOUS QUERIES" }
+    let(:database) { "testdb" }
+    let(:response) do
+      { "results" => [{ "series" => [{ "name" => "otherdb", "columns" => %w(name query),
+                                       "values" =>
+                                          [["clicks_per_hour", "CREATE CONTINUOUS QUERY clicks_per_hour ON otherdb BEGIN SELECT count(name) INTO \"otherdb\".\"default\".clicksCount_1h FROM \"otherdb\".\"default\".clicks GROUP BY time(1h) END"]] },
+                                     { "name" => "testdb", "columns" => %w(name query),
+                                       "values" =>
+                                          [["event_counts", "CREATE CONTINUOUS QUERY event_counts ON testdb BEGIN SELECT count(type) INTO \"testdb\".\"default\".typeCount_10m_byType FROM \"testdb\".\"default\".events GROUP BY time(10m), type END"]] }] }] }
+    end
+
+    let(:expected_result) do
+      [{ "name" => "event_counts", "query" => "CREATE CONTINUOUS QUERY event_counts ON testdb BEGIN SELECT count(type) INTO \"testdb\".\"default\".typeCount_10m_byType FROM \"testdb\".\"default\".events GROUP BY time(10m), type END" }]
+    end
+
+    before do
+      stub_request(:get, "http://influxdb.test:9999/query").with(
+        query: { u: "username", p: "password", q: query }
+      ).to_return(body: JSON.generate(response), status: 200)
+    end
+
+    it "should GET a list of continuous queries for specified db only" do
+      expect(subject.list_continuous_queries(database)).to eq(expected_result)
+    end
+  end
+
+  describe "#create_continuous_query" do
+    let(:name) { "event_counts_per_10m_by_type" }
+    let(:database) { "testdb" }
+    let(:query) do
+      "SELECT COUNT(type) INTO typeCount_10m_byType FROM events GROUP BY time(10m), type"
+    end
+    let(:clause) do
+      ["CREATE CONTINUOUS QUERY #{name} ON #{database} BEGIN", query, "END"].join("\n")
+    end
+
+    before do
+      stub_request(:get, "http://influxdb.test:9999/query").with(
+        query: { u: "username", p: "password", q: clause }
+      )
+    end
+
+    it "should GET to create a new continuous query" do
+      expect(subject.create_continuous_query(name, database, query)).to be_a(Net::HTTPOK)
+    end
+  end
+
+  describe "#delete_continuous_query" do
+    let(:name) { "event_counts_per_10m_by_type" }
+    let(:database) { "testdb" }
+    let(:query) { "DROP CONTINUOUS QUERY #{name} ON #{database}" }
+    before do
+      stub_request(:get, "http://influxdb.test:9999/query").with(
+        query: { u: "username", p: "password", q: query }
+      )
+    end
+
+    it "should GET to remove continuous query" do
+      expect(subject.delete_continuous_query(name, database)).to be_a(Net::HTTPOK)
+    end
+  end
+end

data/spec/influxdb/cases/query_core.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+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)
+    )
+  end
+
+  let(:args) { {} }
+
+  describe '#query' 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'=>[]}]
+      expect(subject.query(query)).to eq(expected_result)
+    end
+  end
+end