hawkular-client 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0c2bd7524ca6889a513ffac38121ecd21626d26c
-  data.tar.gz: c8a90d9d4a3b042baf12c8fd046601d5442ccce1
+  metadata.gz: 6b21f0f14d7546fe626efb1cb3209c1085d22124
+  data.tar.gz: 9b92719c7441a05ce9cfa81a0d0f9b0cfae55553
 SHA512:
-  metadata.gz: d3015ffa0cb3c714b9141a9b6783539b115c556a617911e931bc5905fd7e10bfa37727bd927a9e629e0021027495c01be5c62af8158810091624ce0a5790a6bb
-  data.tar.gz: 64541ba6774f5f67582586acafd3c806861a51b1dc6452848716c8c552ada2db434b2a3c5be37cfd6aef059023d2fe9873a6b9c5f30ec5f706683701dbfe9006
+  metadata.gz: edd53f956611e6df5bba5bafccbbcdbebf2d0228e054216eaf838fd5876566550fb463c4717206121bc90803a1b10ae7b663fbfb3ef66e8ff25c36cc899c060f
+  data.tar.gz: 603b389c5e1712544c3511ba1f07b27b2a44860fb6cdf9972fc4763254c1b0d0f1cde6b769ce3fb2109cd6b140a31bf797e4bcffe690dbaf552466d99f91b52a

data/.gitignore

@@ -8,6 +8,7 @@
 /test/tmp/
 /test/version_tmp/
 /tmp/
+spec/vcr.log
 
 ## Specific to RubyMotion:
 .dat*
@@ -36,3 +37,19 @@ build/
 
 # test config
 spec/endpoint.yml
+
+# IDE files
+.project
+.classpath
+.settings
+.idea
+*.ipr
+*.iml
+*.iws
+nb-configuration.xml
+
+# KDE
+.directory
+
+# OSX
+.DS_Store

data/.rubocop.yml

@@ -0,0 +1,14 @@
+MethodLength:
+  Enabled: false
+ClassLength:
+  Enabled: false
+ModuleLength:
+  Enabled: false
+Metrics/AbcSize:
+  Enabled: false
+Documentation:
+  Enabled: false
+Style/ClassAndModuleChildren:
+  Enabled: false
+Metrics/LineLength:
+  Max: 100

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 2.0.0
+#  - 1.9.3
+#  - jruby-19mode

data/CHANGES.rdoc

@@ -3,3 +3,9 @@
 This document describes the relevant changes beween releases of the
 _hawkular-client_ project.
 
+
+=== V 0.1.1
+
+* Add VCR tests
+* Metrics::Client.new now requries a hash for credentials
+* Code cleanup and enforcement via RuboCop

data/Gemfile

@@ -1,2 +1,2 @@
-source "http://rubygems.org"
+source 'http://rubygems.org'
 gemspec

data/README.rdoc

@@ -15,7 +15,8 @@ A Ruby Hawkular Client.
 == Running the tests
 
 * Copy the file spec/endpoint.yml.example to spec/endpoint.yml
-* Edit the endpoint properties (user, password and host name)
+* Edit the endpoint properties in the file `spec/endpoint.yml`(user, password and host
+ name)
 * From command line run => rake spec
 
 == Logging

data/Rakefile

@@ -1,9 +1,12 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
 
 RSpec::Core::RakeTask.new(:spec) do |task|
-  task.pattern = "./spec/**/*_spec.rb"
+  task.pattern = './spec/**/*_spec.rb'
   task.rspec_opts = ['--color']
 end
 
-task :default => :spec
+RuboCop::RakeTask.new
+
+task default: [:rubocop, :spec]

data/hawkularclient.gemspec

@@ -4,27 +4,33 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'metrics/version'
 
 Gem::Specification.new do |gem|
-  gem.name          = "hawkular-client"
+  gem.name          = 'hawkular-client'
   gem.version       = Hawkular::Metrics::VERSION
-  gem.authors       = ['Libor Zoubek']
-  gem.email         = ['lzoubek@redhat.com']
-  gem.homepage      = "https://github.com/hawkular/hawkular-client-ruby"
-  gem.summary       = %q{A Ruby client for Hawkular}
-  gem.description   = <<-EOS
+  gem.authors       = ['Libor Zoubek', 'Heiko W. Rupp', 'Federico Simoncelli']
+  gem.email         = %w(lzoubek@redhat.com hrupp@redhat.com)
+  gem.homepage      = 'https://github.com/hawkular/hawkular-client-ruby'
+  gem.summary       = 'A Ruby client for Hawkular'
+  gem.license       = 'ASL 2.0'
+  gem.required_ruby_version = '>= 2.0.0'
+  gem.description = <<-EOS
     A Ruby client for Hawkular
   EOS
 
-  gem.files         = `git ls-files`.split($/)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.files         = `git ls-files -z`.split("\x0")
+  gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.require_paths = ["lib"]
+  gem.require_paths = ['lib']
 
   gem.add_runtime_dependency('rest-client')
   gem.add_development_dependency('shoulda')
   gem.add_development_dependency('rspec-rails', '~> 2.6')
   gem.add_development_dependency('rake')
-  gem.add_development_dependency('yardoc')
+  gem.add_development_dependency('yard')
+  gem.add_development_dependency('webmock')
+  gem.add_development_dependency('vcr')
+  gem.add_development_dependency('rubocop', '= 0.34.2')
 
-  gem.rdoc_options << '--title' << gem.name << '--main' << 'README.rdoc' << '--line-numbers' << '--inline-source'
+  gem.rdoc_options << '--title' << gem.name <<
+    '--main' << 'README.rdoc' << '--line-numbers' << '--inline-source'
   gem.extra_rdoc_files = ['README.rdoc', 'CHANGES.rdoc']
 end

data/lib/hawkularclient.rb

@@ -1,40 +1,37 @@
 
 
-require "json"
-require "rest-client"
+require 'json'
+require 'rest-client'
 
 module Hawkular
   # Metrics module provides access to Hawkular Metrics REST API
   # @see http://www.hawkular.org/docs/rest/rest-metrics.html Hawkular Metrics REST API Documentation
   # @example Create Hawkular-Metrics client and start pushing some metric data
   #  # create client instance
-  #  client = Hawkular::Metrics::Client::new("http://server","username","password",{"tenant" => "your tenant ID"})
-  #  # push gauge metric data for metric called "myGauge" (no need to create metric definition unless you wish to specify data retention)
+  #  client = Hawkular::Metrics::Client::new("http://server","username",
+  #                "password",{"tenant" => "your tenant ID"})
+  #  # push gauge metric data for metric called "myGauge" (no need to create metric definition
+  #  # unless you wish to specify data retention)
   #  client.gauges.push_data("myGauge", {:value => 3.1415925})
   module Metrics
   end
 end
 
-require "metrics/types"
-require "metrics/tenant_api"
-require "metrics/metric_api"
-
+require 'metrics/types'
+require 'metrics/tenant_api'
+require 'metrics/metric_api'
 
 module Hawkular::Metrics
-
   class HawkularException < StandardError
     def initialize(message)
       @message = message
       super
     end
 
-    def message
-      @message
-    end
+    attr_reader :message
   end
 
   class Client
-
     # @!visibility private
     attr_reader :credentials, :entrypoint, :options
     # @return [Tenants] access tenants API
@@ -48,79 +45,83 @@ module Hawkular::Metrics
 
     # Construct a new Hawkular Metrics client class.
     # optional parameters
-    # @param entrypoint [String]
-    # @param username [String]
-    # @param password [String]
+    # @param entrypoint [String] Base url of the Hawkular (metrics) server
+    # @param credentials Hash of username, password, token(optional)
     # @param options [Hash{String=>String}] client options
     # @example initialize with Hawkular-tenant option
-    #   Hawkular::Metrics::Client::new("http://server","username","password",{"tenant" => "your tenant ID"})
+    #   Hawkular::Metrics::Client::new("http://server",
+    #     {username:"username",password:"password"},
+    #                          {"tenant" => "your tenant ID"})
     #
-    def initialize(entrypoint='http://localhost:8080/hawkular/metrics',username=nil, password=nil, options={})
+    def initialize(entrypoint = 'http://localhost:8080/hawkular/metrics',
+                   credentials = {},
+                   options = {})
       @entrypoint = entrypoint
-      @credentials = { :username => username, :password => password }
+      @credentials = {
+        username: nil,
+        password: nil,
+        token:    nil
+      }.merge(credentials)
       @options = {
-        :tenant => nil,
+        tenant: nil,
+        ssl_ca_file: nil,
+        verify_ssl: OpenSSL::SSL::VERIFY_PEER,
+        ssl_client_cert: nil,
+        ssl_client_key: nil,
+        headers: {}
       }.merge(options)
 
-      @tenants = Client::Tenants::new self
-      @counters = Client::Counters::new self
-      @gauges = Client::Gauges::new self
-      @avail = Client::Availability::new self
+      @tenants = Client::Tenants.new self
+      @counters = Client::Counters.new self
+      @gauges = Client::Gauges.new self
+      @avail = Client::Availability.new self
     end
 
-
-    def http_get(suburl, headers={})
-      begin
-        res = rest_client(suburl).get(http_headers(headers))
-        puts "#{res}\n" if ENV['HAWKULARCLIENT_LOG_RESPONSE']
-        res.empty? ? {} : JSON.parse(res)
-      rescue
-        handle_fault $!
-      end
+    def http_get(suburl, headers = {})
+      res = rest_client(suburl).get(http_headers(headers))
+      puts "#{res}\n" if ENV['HAWKULARCLIENT_LOG_RESPONSE']
+      res.empty? ? {} : JSON.parse(res)
+    rescue
+      handle_fault $ERROR_INFO
     end
 
-
-    def http_post(suburl, hash, headers={})
-      begin
-        body = JSON.generate(hash)
-        res = rest_client(suburl).post(body, http_headers(headers))
-        puts "#{res}\n" if ENV['HAWKULARCLIENT_LOG_RESPONSE']
-        res.empty? ? {} : JSON.parse(res)
-      rescue
-        handle_fault $!
-      end
+    def http_post(suburl, hash, headers = {})
+      body = JSON.generate(hash)
+      res = rest_client(suburl).post(body, http_headers(headers))
+      puts "#{res}\n" if ENV['HAWKULARCLIENT_LOG_RESPONSE']
+      res.empty? ? {} : JSON.parse(res)
+    rescue
+      handle_fault $ERROR_INFO
     end
 
-    def http_put(suburl, hash, headers={})
-      begin
-        body = JSON.generate(hash)
-        res = rest_client(suburl).put(body, http_headers(headers))
-        puts "#{res}\n" if ENV['HAWKULARCLIENT_LOG_RESPONSE']
-        res.empty? ? {} : JSON.parse(res)
-      rescue
-        handle_fault $!
-      end
+    def http_put(suburl, hash, headers = {})
+      body = JSON.generate(hash)
+      res = rest_client(suburl).put(body, http_headers(headers))
+      puts "#{res}\n" if ENV['HAWKULARCLIENT_LOG_RESPONSE']
+      res.empty? ? {} : JSON.parse(res)
+    rescue
+      handle_fault $ERROR_INFO
     end
 
-    def http_delete(suburl, headers={})
-      begin
-        res = rest_client(suburl).delete(http_headers(headers))
-        puts "#{res}\n" if ENV['HAWKULARCLIENT_LOG_RESPONSE']
-        res.empty? ? {} : JSON.parse(res)
-      rescue
-        handle_fault $!
-      end
+    def http_delete(suburl, headers = {})
+      res = rest_client(suburl).delete(http_headers(headers))
+      puts "#{res}\n" if ENV['HAWKULARCLIENT_LOG_RESPONSE']
+      res.empty? ? {} : JSON.parse(res)
+    rescue
+      handle_fault $ERROR_INFO
     end
 
-
-
     # @!visibility private
     def rest_client(suburl)
       options[:timeout] = ENV['HAWKULARCLIENT_REST_TIMEOUT'] if ENV['HAWKULARCLIENT_REST_TIMEOUT']
+      options[:ssl_ca_file]     = @options[:ssl_ca_file]
+      options[:verify_ssl]      = @options[:verify_ssl]
+      options[:ssl_client_cert] = @options[:ssl_client_cert]
+      options[:ssl_client_key]  = @options[:ssl_client_key]
+      options[:user]            = @credentials[:username]
+      options[:password]        = @credentials[:password]
       # strip @endpoint in case suburl is absolute
-      if suburl.match(/^http/)
-        suburl = suburl[@entrypoint.length,suburl.length]
-      end
+      suburl = suburl[@entrypoint.length, suburl.length] if suburl.match(/^http/)
       RestClient::Resource.new(@entrypoint, options)[suburl]
     end
 
@@ -136,52 +137,44 @@ module Hawkular::Metrics
     end
 
     # @!visibility private
-    def http_headers(headers ={})
-      {}.merge(auth_header)
-        .merge(tenant_header)
-        .merge({
-          :content_type => 'application/json',
-          :accept => 'application/json',
-        })
+    def http_headers(headers = {})
+      {}.merge(tenant_header)
+        .merge(token_header)
+        .merge(@options[:headers])
+        .merge(content_type: 'application/json',
+               accept: 'application/json')
         .merge(headers)
     end
 
     # timestamp of current time
     # @return [Integer] timestamp
     def now
-      Integer(Time::now.to_f * 1000)
+      Integer(Time.now.to_f * 1000)
     end
 
     private
 
+    def token_header
+      @credentials[:token].nil? ? {} : { 'Authorization' => "Bearer #{@credentials[:token]}" }
+    end
 
-      def tenant_header
-        @options[:tenant].nil? ? {} : { :'Hawkular-Tenant' => @options[:tenant], "tenantId" => @options[:tenant] }
-      end
-
-
-      def auth_header
-        if @credentials[:username].nil? and @credentials[:password].nil?
-          return {}
-        end
-        # This is the method for strict_encode64:
-        encoded_credentials = ["#{@credentials[:username]}:#{@credentials[:password]}"].pack("m0").gsub(/\n/,'')
-        {:authorization => "Basic " + encoded_credentials }
-      end
+    def tenant_header
+      @options[:tenant].nil? ? {} : { :'Hawkular-Tenant' => @options[:tenant],
+                                      'tenantId' => @options[:tenant] }
+    end
 
-      def handle_fault(f)
-        if defined? f.http_body and !f.http_body.nil?
-          begin
-            fault = "#{f.errorMsg}\n%s\n" % JSON.parse(f.http_body)["errorMsg"]
-          rescue
-            fault = f.http_body
-            raise HawkularException::new(fault)
-          end
-        else
-          raise f
+    def handle_fault(f)
+      if f.respond_to?(:http_body) && !f.http_body.nil?
+        begin
+          json_body = JSON.parse(f.http_body)
+          fault_message = json_body['errorMsg'] || f.http_body
+        rescue JSON::ParserError
+          fault_message = f.http_body
         end
-
+        fail HawkularException, fault_message
+      else
+        fail f
       end
+    end
   end
-
 end

data/lib/metrics/metric_api.rb

@@ -1,15 +1,15 @@
+require 'erb'
+
 module Hawkular::Metrics
   class Client
-
-      # @!visibility private
-      def default_timestamp(array)
-        n = now
-        array.each { |p|
-          p[:timestamp] ||= n
-        }
-        array
+    # @!visibility private
+    def default_timestamp(array)
+      n = now
+      array.each do |p|
+        p[:timestamp] ||= n
       end
-
+      array
+    end
 
     # Push data for multiple metrics of all supported types
     # @param gauges [Array]
@@ -17,29 +17,27 @@ module Hawkular::Metrics
     # @param availabilities [Array]
     # @example push datapoints of 2 counter metrics
     #    client = Hawkular::Metrics::client::new
-    #    client.push_data(counters: [{:id => "counter1", :data => [{:value => 1}, {:value => 2}]},{:id => "counter2", :data => [{:value => 1}, {:value => 3}]}])
+    #    client.push_data(counters: [{:id => "counter1", :data => [{:value => 1}, {:value => 2}]},
+    #                        {:id => "counter2", :data => [{:value => 1}, {:value => 3}]}])
     # @example push gauge and availability datapoints
-    #    client.push_data(gauges: [{:id => "gauge1", :data => [{:value => 1}, {:value => 2}]}], availabilities: [{:id => "avail1", :data => [{:value => "up"}]}])
+    #    client.push_data(gauges: [{:id => "gauge1", :data => [{:value => 1}, {:value => 2}]}],
+    #                           availabilities: [{:id => "avail1", :data => [{:value => "up"}]}])
     def push_data(gauges: [], counters: [], availabilities: [])
-      gauges.each { |g|
-        default_timestamp g[:data]
-      }
-      counters.each { |g|
-        default_timestamp g[:data]
-      }
-      availabilities.each { |g|
-        default_timestamp g[:data]
-      }
-      data = {:gauges => gauges, :counters => counters, :availabilities => availabilities}
-      http_post("/metrics/data", data)
+      gauges.each { |g| default_timestamp g[:data] }
+      counters.each { |g| default_timestamp g[:data] }
+      availabilities.each { |g| default_timestamp g[:data] }
+
+      data = { gauges: gauges, counters: counters, availabilities: availabilities }
+      http_post('/metrics/data', data)
     end
 
-    # Base class for accessing metric definition and data of all types (counters, gauges, availabilities)
+    # Base class for accessing metric definition and data of all
+    # types (counters, gauges, availabilities).
     class Metrics
-
       # @param client [Client]
       # @param metricType [String] metric type (one of "counter", "gauge", "availability")
-      # @param resource [String] REST resource name for accessing metrics of given type (one of "counters", "gauges", "availability")
+      # @param resource [String] REST resource name for accessing metrics
+      #    of given type (one of "counters", "gauges", "availability")
       def initialize(client, metricType, resource)
         @client = client
         @type = metricType
@@ -50,37 +48,35 @@ module Hawkular::Metrics
       # @param definition [MetricDefinition or Hash] gauge/counter/availability options.
       # @example Create gauge metric definition using Hash
       #   client = Hawkular::Metrics::client::new
-      #   client.gauges.create({:id => "id", :dataRetention => 90, :tags => {:tag1 => "value1"}, :tenantId => "your tenant id"})
+      #   client.gauges.create({:id => "id", :dataRetention => 90,
+      #                         :tags => {:tag1 => "value1"}, :tenantId => "your tenant id"})
       def create(definition)
-        if definition.kind_of?(Hawkular::Metrics::MetricDefinition)
+        if definition.is_a?(Hawkular::Metrics::MetricDefinition)
           definition = definition.hash
         end
-        @client.http_post('/'+@resource, definition)
+        @client.http_post('/' + @resource, definition)
       end
 
       # Query metric definitions by tags
       # @param tags [Hash]
       # @return [Array[MetricDefinition]]
       def query(tags)
-          tags = tags.map do |k,v|
-            "#{k}:#{v}"
-          end
-          @client.http_get("/metrics/?type=#{@type}&tags=#{tags.join(',')}").map do |g|
-            Hawkular::Metrics::MetricDefinition::new(g)
-          end
+        @client.http_get("/metrics/?type=#{@type}&tags=#{tags_param(tags)}").map do |g|
+          Hawkular::Metrics::MetricDefinition.new(g)
+        end
       end
 
       # Get metric definition by id
       # @param id [String]
       # @return [MetricDefinition]
       def get(id)
-        Hawkular::Metrics::MetricDefinition::new(@client.http_get("/#{@resource}/#{id}"))
+        Hawkular::Metrics::MetricDefinition.new(@client.http_get("/#{@resource}/#{id}"))
       end
 
       # update tags for given metric definition
       # @param metricDefinition [MetricDefinition]
       def update_tags(metricDefinition)
-        @client.http_put("/#{@resource}/#{metricDefinition.id}/tags",metricDefinition.hash[:tags])
+        @client.http_put("/#{@resource}/#{metricDefinition.id}/tags", metricDefinition.hash[:tags])
       end
 
       # Push metric data
@@ -89,15 +85,15 @@ module Hawkular::Metrics
       # @example Push counter data with timestamp
       #   client = Hawkular::Metics::Client::new
       #   now = Integer(Time::now.to_f * 1000)
-      #   client.counters.push_data("counter id", [{:value => 1, :timestamp => now - 1000}, {:value => 2, :timestamp => now}])
+      #   client.counters.push_data("counter id", [{:value => 1, :timestamp => now - 1000},
+      #                                            {:value => 2, :timestamp => now}])
       # @example Push single availability without timestamp
       #   client.avail.push_data("avail_id", {:value => "up"})
       # @example Push gague data with tags
-      #   client.gagues.push_data("gauge_id", [{:value => 0.1, :tags => {:tagName => "myMin"}},{:value => 99.9, :tags => {:tagName => "myMax"}}])
+      #   client.gagues.push_data("gauge_id", [{:value => 0.1, :tags => {:tagName => "myMin"}},
+      #                                        {:value => 99.9, :tags => {:tagName => "myMax"}}])
       def push_data(id, data)
-        if !data.kind_of?(Array)
-          data = [data]
-        end
+        data = [data] unless data.is_a?(Array)
 
         @client.default_timestamp data
         @client.http_post("/#{@resource}/#{id}/data", data)
@@ -107,20 +103,41 @@ module Hawkular::Metrics
       # @param id [String] metric definition id
       # @param starts [Integer] optional timestamp (default now - 8h)
       # @param ends [Integer] optional timestamp (default now)
+      # @param bucketDuration [String] optional interval (default no aggregation)
       # @return [Array[Hash]] datapoints
       # @see #push_data #push_data for datapoint detail
-      def get_data(id, starts: nil, ends: nil)
-        params = {:start => starts, :end => ends}
-        params.delete_if { |k, v| v.nil? }
-        resp = @client.http_get("/#{@resource}/#{id}/data/?"+URI.encode_www_form(params))
-        return [] if !resp.kind_of?(Array) # API returns no content (empty Hash) instead of empty array
-        resp
+      def get_data(id, starts: nil, ends: nil, bucketDuration: nil)
+        params = { start: starts, end: ends, bucketDuration: bucketDuration }
+        resp = @client.http_get("/#{@resource}/#{ERB::Util.url_encode(id)}/data/?" +
+                 encode_params(params))
+        resp.is_a?(Array) ? resp : [] # API returns no content (empty Hash) instead of empty array
+      end
+
+      # Retrieve metric datapoints by tags
+      # @param tags [Hash]
+      # @param starts [Integer] optional timestamp (default now - 8h)
+      # @param ends [Integer] optional timestamp (default now)
+      # @param bucketDuration [String] optional interval (default no aggregation)
+      # @return [Array[Hash]] datapoints
+      # @see #push_data #push_data for datapoint detail
+      def get_data_by_tags(tags, starts: nil, ends: nil, bucketDuration: nil)
+        params = { tags: tags_param(tags), start: starts,
+                   end: ends, bucketDuration: bucketDuration }
+        resp = @client.http_get("/#{@resource}/data/?" + encode_params(params))
+        resp.is_a?(Array) ? resp : [] # API returns no content (empty Hash) instead of empty array
+      end
+
+      def tags_param(tags)
+        tags.map { |k, v| "#{k}:#{v}" }.join(',')
+      end
+
+      def encode_params(params)
+        URI.encode_www_form(params.select { |_k, v| !v.nil? })
       end
     end
 
     # Class that interracts with "gauge" metric types
     class Gauges < Metrics
-
       # @param client [Client]
       def initialize(client)
         super(client, 'gauge', 'gauges')
@@ -131,46 +148,46 @@ module Hawkular::Metrics
       # @param starts [Integer] timestamp (default now - 8h)
       # @param ends [Integer] timestamp (default now)
       # @param threshold [Numeric]
-      # @param operation [String] A comparison operation to perform between values and the threshold. Supported operations include "ge", "gte", "lt", "lte", and "eq"
+      # @param operation [String] A comparison operation to perform between values and the
+      #   threshold. Supported operations include "ge", "gte", "lt", "lte", and "eq"
       # @example Get time periods when metric "gauge1" was under 10 in past 4 hours
       #   before4h = client.now - (4 * 60 * 60 * 1000)
       #   client.gauges.get_periods("gauge1", starts: before4h, threshold: 10, operation: "lte")
-      def get_periods(id, starts: nil, ends: nil, threshold:, operation:)
-          params = {:start => starts, :end => ends, :threshold => threshold, :op => operation}
-          params.delete_if { |k, v| v.nil? }
-          @client.http_get("/#{@resource}/#{id}/periods?"+URI.encode_www_form(params))
+      def get_periods(id, starts: nil, ends: nil, threshold: nil, operation: nil)
+        params = { start: starts, end: ends, threshold: threshold, op: operation }
+        @client.http_get("/#{@resource}/#{id}/periods?" + encode_params(params))
       end
-
     end
 
     # Class that interracts with "counter" metric types
     class Counters < Metrics
-
       # @param client [Client]
       def initialize(client)
         super(client, 'counter', 'counters')
       end
 
-      # get rate for given metric
-      # @param id [String] metric ID
-      def get_rate(id:)
-        @client.http_get("/#{@resource}/#{id}/rate")
+      # Retrieve metric rate points
+      # @param id [String] metric definition id
+      # @param starts [Integer] optional timestamp (default now - 8h)
+      # @param ends [Integer] optional timestamp (default now)
+      # @param bucketDuration [String] optional interval (default no
+      #                       aggregation)
+      # @return [Array[Hash]] rate points
+      def get_rate(id, starts: nil, ends: nil, bucketDuration: nil)
+        path = "/#{@resource}/#{ERB::Util.url_encode(id)}/rate"
+        params = { start: starts, end: ends, bucketDuration: bucketDuration }
+        resp = @client.http_get(path + '?' + encode_params(params))
+        # API returns no content (empty Hash) instead of empty array
+        resp.is_a?(Array) ? resp : []
       end
     end
 
     # Class that interracts with "availability" metric types
     class Availability < Metrics
-
       # @param client [Client]
       def initialize(client)
         super(client, 'availability', 'availability')
       end
-
     end
-
-
-    private
-
-
   end
 end