efigence-influxdb 0.1.0

data/Rakefile

@@ -0,0 +1,22 @@
+require "bundler/gem_tasks"
+
+targeted_files = ARGV.drop(1)
+file_pattern = targeted_files.empty? ? 'spec/**/*_spec.rb' : targeted_files
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = FileList[file_pattern]
+end
+
+RSpec.configure do |config|
+  config.color = true
+  config.formatter = :documentation
+end
+
+task default: :spec
+
+task :console do
+  sh 'pry -r ./lib/influxdb.rb'
+end

data/efigence-influxdb.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'influxdb/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "efigence-influxdb"
+  spec.version       = InfluxDB::VERSION
+  spec.authors       = ["Jacek Grzybowski", "Todd Persen"]
+  spec.email         = ["jgrzybowski@efigence.com"]
+  spec.description   = %q{This is a fork of official Ruby library for InfluxDB meant for v0.9.x support.}
+  spec.summary       = %q{Ruby library for InfluxDB.}
+  spec.homepage      = "https://github.com/efigence/influxdb-ruby/tree/support_v0.9.x"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "json"
+  spec.add_runtime_dependency "cause"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 3.0.0"
+  spec.add_development_dependency "webmock"
+end

data/lib/influxdb.rb

@@ -0,0 +1,21 @@
+require "influxdb/version"
+require "influxdb/errors"
+require "influxdb/logging"
+require "influxdb/max_queue"
+require "influxdb/point_value"
+require "influxdb/config"
+
+require "influxdb/writer/async"
+require "influxdb/writer/udp"
+
+require "influxdb/query/core"
+require "influxdb/query/cluster"
+require "influxdb/query/database"
+require "influxdb/query/series"
+require "influxdb/query/shard"
+require "influxdb/query/user"
+require "influxdb/query/continuous_query"
+require "influxdb/query/shard_space"
+
+require "influxdb/client/http"
+require "influxdb/client"

data/lib/influxdb/client.rb

@@ -0,0 +1,77 @@
+require 'json'
+require 'cause'
+
+module InfluxDB
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/AbcSize
+
+  # InfluxDB client class
+  class Client
+    attr_reader :config, :writer
+
+    include InfluxDB::Logging
+    include InfluxDB::HTTP
+    include InfluxDB::Query::Core
+    include InfluxDB::Query::Cluster
+    include InfluxDB::Query::Database
+    include InfluxDB::Query::Shard
+    include InfluxDB::Query::Series
+    include InfluxDB::Query::User
+    include InfluxDB::Query::ContinuousQuery
+    include InfluxDB::Query::ShardSpace
+
+    # Initializes a new InfluxDB client
+    #
+    # === Examples:
+    #
+    #  # connect to localhost using root/root
+    #  # as the credentials and doesn't connect to a db
+    #
+    #  InfluxDB::Client.new
+    #
+    #  # connect to localhost using root/root
+    #  # as the credentials and 'db' as the db name
+    #
+    #  InfluxDB::Client.new 'db'
+    #
+    #  # override username, other defaults remain unchanged
+    #
+    #  InfluxDB::Client.new username: 'username'
+    #
+    #  # override username, use 'db' as the db name
+    #  Influxdb::Client.new 'db', username: 'username'
+    #
+    # === Valid options in hash
+    #
+    # +:host+:: the hostname to connect to
+    # +:port+:: the port to connect to
+    # +:path+:: the specified path prefix when building the url e.g.: /prefix/db/dbname...
+    # +:username+:: the username to use when executing commands
+    # +:password+:: the password associated with the username
+    # +:use_ssl+:: use ssl to connect
+    def initialize(*args)
+      opts = args.last.is_a?(Hash) ? args.last : {}
+      opts[:database] = args.first if args.first.is_a? String
+      @config = InfluxDB::Config.new(opts)
+      @stopped = false
+
+      @writer = self
+
+      if config.async?
+        @writer = InfluxDB::Writer::Async.new(self, config.async)
+      elsif config.udp?
+        @writer = InfluxDB::Writer::UDP.new(self, config.udp)
+      end
+
+      at_exit { stop! } if config.retry > 0
+    end
+
+    def stop!
+      @stopped = true
+    end
+
+    def stopped?
+      @stopped
+    end
+  end
+end

data/lib/influxdb/client/http.rb

@@ -0,0 +1,98 @@
+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.use_ssl = config.use_ssl
+        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 e, "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
+      raise InfluxDB::QueryError.new 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
+  end
+end

data/lib/influxdb/config.rb

@@ -0,0 +1,60 @@
+module InfluxDB
+  # InfluxDB client configuration
+  class Config
+    AUTH_METHODS = %w(params basic_auth)
+
+    attr_accessor :hosts,
+                  :port,
+                  :username,
+                  :password,
+                  :database,
+                  :time_precision,
+                  :use_ssl,
+                  :auth_method,
+                  :initial_delay,
+                  :max_delay,
+                  :open_timeout,
+                  :read_timeout,
+                  :retry,
+                  :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)
+      @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)
+      @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

@@ -0,0 +1,40 @@
+require "net/http"
+require "zlib"
+
+module InfluxDB # :nodoc:
+  class Error < StandardError
+  end
+
+  class AuthenticationError < Error
+  end
+
+  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,
+    Errno::ECONNABORTED,
+    Errno::ECONNREFUSED,
+    Errno::ECONNRESET,
+    Errno::EHOSTUNREACH,
+    Errno::EINVAL,
+    Errno::ENETUNREACH,
+    Net::HTTPBadResponse,
+    Net::HTTPHeaderSyntaxError,
+    Net::ProtocolError,
+    SocketError,
+    Zlib::GzipFile::Error
+  ]
+
+  NET_HTTP_EXCEPTIONS << OpenSSL::SSL::SSLError if defined?(OpenSSL)
+end

data/lib/influxdb/logging.rb

@@ -0,0 +1,22 @@
+require 'logger'
+
+module InfluxDB
+  module Logging # :nodoc:
+    PREFIX = "[InfluxDB] "
+
+    class << self
+      attr_writer :logger
+    end
+
+    def self.logger
+      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
+  end
+end

data/lib/influxdb/max_queue.rb

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

data/lib/influxdb/point_value.rb

@@ -0,0 +1,31 @@
+module InfluxDB
+  class PointValue
+    attr_reader :series, :values, :tags, :timestamp
+
+    def initialize(data)
+      @series    = data[:series].gsub(/\s/, '\ ')
+      @values    = stringify(data[:values])
+      @tags      = stringify(data[:tags])
+      @timestamp = data[:timestamp]
+    end
+
+    def dump
+      dump = "#{@series}"
+      dump << ",#{@tags}" if @tags
+      dump << " #{@values}"
+      dump << " #{@timestamp}" if @timestamp
+      dump
+    end
+
+    private
+
+    def stringify(hash)
+      return nil unless hash && !hash.empty?
+      hash.map do |k,v|
+        key = k.to_s.gsub(/\s/, '\ ')
+        val = v.is_a?(String) ? v.gsub(/\s/, '\ ') : v
+        "#{key}=#{val}"
+      end.join(',')
+    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.delete_if {|k,_| k == 'admin'}}
+      end
+
+      def revoke_cluster_admin_privileges(username)
+        execute("REVOKE ALL PRIVILEGES FROM #{username}")
+      end
+    end
+  end
+end