influxdb 0.1.9 → 0.2.0

data/lib/influxdb/client/http.rb

@@ -0,0 +1,123 @@
+require 'uri'
+require 'cgi'
+require 'net/http'
+require 'net/https'
+
+module InfluxDB
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/AbcSize
+  module HTTP # :nodoc:
+    def get(url, options = {})
+      connect_with_retry do |http|
+        response = do_request http, Net::HTTP::Get.new(url)
+        if response.is_a? Net::HTTPSuccess
+          handle_successful_response(response, options)
+        elsif response.is_a? Net::HTTPUnauthorized
+          fail InfluxDB::AuthenticationError, response.body
+        else
+          resolve_error(response.body)
+        end
+      end
+    end
+
+    def post(url, data)
+      headers = { "Content-Type" => "application/octet-stream" }
+      connect_with_retry do |http|
+        response = do_request http, Net::HTTP::Post.new(url, headers), data
+        if response.is_a? Net::HTTPSuccess
+          return response
+        elsif response.is_a? Net::HTTPUnauthorized
+          fail InfluxDB::AuthenticationError, response.body
+        else
+          resolve_error(response.body)
+        end
+      end
+    end
+
+    private
+
+    def connect_with_retry(&block)
+      hosts = config.hosts.dup
+      delay = config.initial_delay
+      retry_count = 0
+
+      begin
+        hosts.push(host = hosts.shift)
+        http = Net::HTTP.new(host, config.port)
+        http.open_timeout = config.open_timeout
+        http.read_timeout = config.read_timeout
+
+        http = setup_ssl(http)
+
+        block.call(http)
+
+      rescue Timeout::Error, *InfluxDB::NET_HTTP_EXCEPTIONS => e
+        retry_count += 1
+        if (config.retry == -1 || retry_count <= config.retry) && !stopped?
+          log :error, "Failed to contact host #{host}: #{e.inspect} - retrying in #{delay}s."
+          sleep delay
+          delay = [config.max_delay, delay * 2].min
+          retry
+        else
+          raise InfluxDB::ConnectionError, "Tried #{retry_count - 1} times to reconnect but failed."
+        end
+      ensure
+        http.finish if http.started?
+      end
+    end
+
+    def do_request(http, req, data = nil)
+      req.basic_auth config.username, config.password if basic_auth?
+      req.body = data if data
+      http.request(req)
+    end
+
+    def basic_auth?
+      config.auth_method == 'basic_auth'
+    end
+
+    def resolve_error(response)
+      if response =~ /Couldn\'t find series/
+        fail InfluxDB::SeriesNotFound, response
+      else
+        fail InfluxDB::Error, response
+      end
+    end
+
+    def handle_successful_response(response, options)
+      parsed_response = JSON.parse(response.body)    if response.body
+      errors = errors_from_response(parsed_response) if parsed_response
+      fail InfluxDB::QueryError,  errors             if errors
+      options.fetch(:parse, false) ? parsed_response : response
+    end
+
+    def errors_from_response(parsed_resp)
+      parsed_resp.is_a?(Hash) && parsed_resp.fetch('results', [])
+        .fetch(0, {})
+        .fetch('error', nil)
+    end
+
+    def setup_ssl(http)
+      http.use_ssl = config.use_ssl
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE unless config.verify_ssl
+
+      return http unless config.use_ssl
+
+      http.cert_store = generate_cert_store
+      http
+    end
+
+    def generate_cert_store
+      store = OpenSSL::X509::Store.new
+      store.set_default_paths
+      if config.ssl_ca_cert
+        if File.directory?(config.ssl_ca_cert)
+          store.add_path(config.ssl_ca_cert)
+        else
+          store.add_file(config.ssl_ca_cert)
+        end
+      end
+      store
+    end
+  end
+end

data/lib/influxdb/config.rb

@@ -0,0 +1,66 @@
+module InfluxDB
+  # InfluxDB client configuration
+  class Config
+    AUTH_METHODS = %w(params basic_auth)
+
+    attr_accessor :hosts,
+                  :port,
+                  :username,
+                  :password,
+                  :database,
+                  :time_precision,
+                  :use_ssl,
+                  :verify_ssl,
+                  :ssl_ca_cert,
+                  :auth_method,
+                  :initial_delay,
+                  :max_delay,
+                  :open_timeout,
+                  :read_timeout,
+                  :retry,
+                  :prefix,
+                  :denormalize
+
+    attr_reader :async, :udp
+
+    # rubocop:disable all
+    def initialize(opts = {})
+      @database = opts[:database]
+      @hosts = Array(opts[:hosts] || opts[:host] || ["localhost"])
+      @port = opts.fetch(:port, 8086)
+      @prefix = opts.fetch(:prefix, '')
+      @username = opts.fetch(:username, "root")
+      @password = opts.fetch(:password, "root")
+      @auth_method = AUTH_METHODS.include?(opts[:auth_method]) ? opts[:auth_method] : "params"
+      @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")
+      @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)
+      @retry =
+        case @retry
+        when Integer
+          @retry
+        when true, nil
+          -1
+        when false
+          0
+        end
+    end
+
+    def udp?
+      !!udp
+    end
+
+    def async?
+      !!async
+    end
+  end
+end

data/lib/influxdb/errors.rb

@@ -1,7 +1,7 @@
 require "net/http"
 require "zlib"
 
-module InfluxDB
+module InfluxDB # :nodoc:
   class Error < StandardError
   end
 
@@ -11,9 +11,15 @@ module InfluxDB
   class ConnectionError < Error
   end
 
+  class SeriesNotFound < Error
+  end
+
   class JSONParserError < Error
   end
 
+  class QueryError < Error
+  end
+
   # Taken from: https://github.com/lostisland/faraday/blob/master/lib/faraday/adapter/net_http.rb
   NET_HTTP_EXCEPTIONS = [
     EOFError,
@@ -27,7 +33,7 @@ module InfluxDB
     Net::HTTPHeaderSyntaxError,
     Net::ProtocolError,
     SocketError,
-    Zlib::GzipFile::Error,
+    Zlib::GzipFile::Error
   ]
 
   NET_HTTP_EXCEPTIONS << OpenSSL::SSL::SSLError if defined?(OpenSSL)

data/lib/influxdb/{logger.rb → logging.rb}

@@ -1,19 +1,20 @@
 require 'logger'
 
 module InfluxDB
-  module Logging
+  module Logging # :nodoc:
     PREFIX = "[InfluxDB] "
 
-    def self.logger=(new_logger)
-      @logger = new_logger
+    class << self
+      attr_writer :logger
     end
 
     def self.logger
-      return @logger unless @logger.nil?
-      @logger = ::Logger.new(STDERR).tap {|logger| logger.level = Logger::INFO}
+      return false if @logger == false
+      @logger ||= ::Logger.new(STDERR).tap { |logger| logger.level = Logger::INFO }
     end
 
     private
+
     def log(level, message)
       InfluxDB::Logging.logger.send(level.to_sym, PREFIX + message) if InfluxDB::Logging.logger
     end

data/lib/influxdb/max_queue.rb

@@ -1,11 +1,12 @@
 require "thread"
 
 module InfluxDB
+  # Queue with max length limit
   class MaxQueue < Queue
     attr_reader :max
 
     def initialize(max = 10_000)
-      raise ArgumentError, "queue size must be positive" unless max > 0
+      fail ArgumentError, "queue size must be positive" unless max > 0
       @max = max
       super()
     end

data/lib/influxdb/point_value.rb

@@ -1,36 +1,38 @@
-require 'json'
-
 module InfluxDB
-
+  # Convert data point to string using Line protocol
   class PointValue
-    attr_accessor :value
+    attr_reader :series, :values, :tags, :timestamp
 
-    def initialize(value)
-      @value = value
+    def initialize(data)
+      @series    = data[:series].gsub(/\s/, '\ ').gsub(',','\,')
+      @values    = stringify(data[:values])
+      @tags      = stringify(data[:tags])
+      @timestamp = data[:timestamp]
     end
 
     def dump
-      if value.is_a?(Array) || value.is_a?(Hash)
-        JSON.generate(value)
-      else
-        value
-      end
+      dump = "#{@series}"
+      dump << ",#{@tags}" if @tags
+      dump << " #{@values}"
+      dump << " #{@timestamp}" if @timestamp
+      dump
     end
 
-    def load
-      if maybe_json?
-        begin
-          JSON.parse(value)
-        rescue JSON::ParserError => e
-          value
-        end
-      else
-        value
-      end
-    end
+    private
 
-    def maybe_json?
-      value.is_a?(String) && value =~ /\A(\{|\[).*(\}|\])$/
+    def stringify(hash)
+      return nil unless hash && !hash.empty?
+      hash.map do |k, v|
+        key = k.to_s.gsub(/\s/, '\ ').gsub(',','\,')
+        val = v
+        if val.is_a?(String)
+          val.gsub!(/\s/, '\ ')
+          val.gsub!(',', '\,')
+          val.gsub!('"', '\"')
+          val = '"' + val + '"'
+        end
+        "#{key}=#{val}"
+      end.join(',')
     end
   end
-end
+end

data/lib/influxdb/query/cluster.rb

@@ -0,0 +1,17 @@
+module InfluxDB
+  module Query
+    module Cluster # :nodoc:
+      def create_cluster_admin(username, password)
+        execute("CREATE USER #{username} WITH PASSWORD '#{password}' WITH ALL PRIVILEGES")
+      end
+
+      def list_cluster_admins
+        list_users.select { |u| u['admin'] }.map { |u| u['username'] }
+      end
+
+      def revoke_cluster_admin_privileges(username)
+        execute("REVOKE ALL PRIVILEGES FROM #{username}")
+      end
+    end
+  end
+end

data/lib/influxdb/query/continuous_query.rb

@@ -0,0 +1,22 @@
+module InfluxDB
+  module Query
+    module ContinuousQuery # :nodoc:
+      def list_continuous_queries(database)
+        resp = execute("SHOW CONTINUOUS QUERIES", parse: true)
+        fetch_series(resp).select { |v| v['name'] == database }
+          .fetch(0, {})
+          .fetch('values', [])
+          .map { |v| { 'name' => v.first, 'query' => v.last } }
+      end
+
+      def create_continuous_query(name, database, query)
+        clause = ["CREATE CONTINUOUS QUERY #{name} ON #{database} BEGIN", query, "END"].join("\n")
+        execute(clause)
+      end
+
+      def delete_continuous_query(name, database)
+        execute("DROP CONTINUOUS QUERY #{name} ON #{database}")
+      end
+    end
+  end
+end

data/lib/influxdb/query/core.rb

@@ -0,0 +1,110 @@
+module InfluxDB
+  module Query # :nodoc: all
+    # rubocop:disable Metrics/AbcSize
+    module Core
+      def ping
+        get "/ping"
+      end
+
+      # 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)
+        series = fetch_series(get(url, parse: true))
+
+        if block_given?
+          series.each do |s|
+            yield s['name'], s['tags'], denormalize ? denormalize_series(s) : raw_values(s)
+          end
+        else
+          denormalize ? denormalized_series_list(series) : series
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      # Example:
+      # write_points([
+      #   {
+      #     series: 'cpu',
+      #     tags: { host: 'server_nl', regios: 'us' },
+      #     values: {internal: 5, external: 6},
+      #     timestamp: 1422568543702900257
+      #   },
+      #   {
+      #     series: 'gpu',
+      #     values: {value: 0.9999},
+      #   }
+      # ])
+      def write_points(data, precision = nil)
+        data = data.is_a?(Array) ? data : [data]
+        payload = generate_payload(data)
+        writer.write(payload, precision)
+      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)
+      end
+
+      def write(data, precision)
+        precision ||= config.time_precision
+        url = full_url("/write", db: config.database, precision: precision)
+        post(url, data)
+      end
+
+      private
+
+      def denormalized_series_list(series)
+        series.map do |s|
+          {
+            'name' => s['name'],
+            'tags' => s['tags'],
+            'values' => denormalize_series(s)
+          }
+        end
+      end
+
+      def fetch_series(response)
+        response.fetch('results', [])
+          .fetch(0, {})
+          .fetch('series', [])
+      end
+
+      def generate_payload(data)
+        data.map do |point|
+          InfluxDB::PointValue.new(point).dump
+        end.join("\n")
+      end
+
+      def execute(query, options = {})
+        url = full_url("/query", q: query)
+        get(url, options)
+      end
+
+      def denormalize_series(series)
+        Array(series["values"]).map do |values|
+          Hash[series["columns"].zip(values)]
+        end
+      end
+
+      def raw_values(series)
+        series.select { |k, _| %w(columns values).include?(k) }
+      end
+
+      def full_url(path, params = {})
+        unless basic_auth?
+          params[:u] = config.username
+          params[:p] = config.password
+        end
+
+        query = params.map { |k, v| [CGI.escape(k.to_s), "=", CGI.escape(v.to_s)].join }.join("&")
+
+        URI::Generic.build(path: File.join(config.prefix, path), query: query).to_s
+      end
+    end
+  end
+end