wavefront-sdk 4.0.0 → 5.2.1

data/lib/wavefront-sdk/query.rb

@@ -43,7 +43,6 @@ module Wavefront
       options[:s] = parse_time(t_start, true)
       options[:e] = parse_time(t_end, true) if t_end
 
-      options.delete_if { |k, v| v == false && k != :i }
       api.get('api', options)
     end
 

data/lib/wavefront-sdk/role.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_relative 'core/api'
+require_relative 'api_mixins/user'
+
+module Wavefront
+  #
+  # Manage and query Wavefront roles
+  #
+  class Role < CoreApi
+    include Wavefront::Mixin::User
+
+    def update_keys
+      %i[id name description]
+    end
+
+    # GET /api/v2/role
+    # Get all roles for a customer
+    # @param offset [Int] alert at which the list begins
+    # @param limit [Int] the number of alerts to return
+    # @return [Wavefront::Response]
+    #
+    def list(offset = 0, limit = 100)
+      api.get('', offset: offset, limit: limit)
+    end
+
+    # POST /api/v2/role
+    # Create a specific role
+    # @param body [Hash] a hash of parameters describing the role.  Please
+    #   refer to the Wavefront Swagger docs for key:value information
+    # @return [Wavefront::Response]
+    #
+    def create(body)
+      raise ArgumentError unless body.is_a?(Hash)
+
+      api.post('', body, 'application/json')
+    end
+
+    # DELETE /api/v2/role/{id}
+    # Delete a specific role
+    # @param id [String] ID of the role
+    # @return [Wavefront::Response]
+    #
+    def delete(id)
+      wf_role_id?(id)
+      api.delete(id)
+    end
+
+    # GET /api/v2/role/{id}
+    # Get a specific role
+    # @param id [String] ID of the role
+    # @return [Wavefront::Response]
+    #
+    def describe(id)
+      wf_role_id?(id)
+      api.get(id)
+    end
+
+    # PUT /api/v2/role/{id}
+    # Update a specific role
+    # @param id [String] role ID
+    # @param body [Hash] key-value hash of the parameters you wish to change
+    # @param modify [true, false] if true, use {#describe()} to get a hash
+    #   describing the existing object, and modify that with the new body. If
+    #   false, pass the new body straight through.
+    # @return [Wavefront::Response]
+    #
+    def update(id, body, modify = true)
+      wf_role_id?(id)
+      raise ArgumentError unless body.is_a?(Hash)
+
+      return api.put(id, body, 'application/json') unless modify
+
+      api.put(id, hash_for_update(describe(id).response, body),
+              'application/json')
+    end
+
+    # POST /api/v2/role/{id}/addAssignees
+    # Add multiple users and user groups to a specific role
+    # @param id [String] role ID
+    # @param assignees [Array[String]] list of roles or accounts to be added
+    # @return [Wavefront::Response]
+    #
+    def add_assignees(id, assignees)
+      wf_role_id?(id)
+      validate_user_list(assignees)
+      api.post([id, 'addAssignees'].uri_concat, assignees, 'application/json')
+    end
+
+    # POST /api/v2/role/{id}/removeAssignees
+    # Remove multiple users and user groups from a specific role
+    # @param id [String] role ID
+    # @param assignees [Array[String]] list of roles or accounts to be removed
+    # @return [Wavefront::Response]
+    #
+    def remove_assignees(id, assignees)
+      wf_role_id?(id)
+      validate_user_list(assignees)
+      api.post([id, 'removeAssignees'].uri_concat,
+               assignees,
+               'application/json')
+    end
+
+    # POST /api/v2/role/grant/{permission}
+    # Grants a single permission to role(s)
+    # @param permission [String] permission to grant
+    # @param roles [Array[String]] list of roles to receive permission
+    # @return [Wavefront::Response]
+    #
+    def grant(permission, roles)
+      wf_permission?(permission)
+      validate_role_list(roles)
+      api.post(['grant', permission].uri_concat, roles, 'application/json')
+    end
+
+    # POST /api/v2/role/revoke/{permission}
+    # Revokes a single permission from role(s)
+    # @param permission [String] permission to revoke
+    # @param roles [Array[String]] list of roles to lose permission
+    # @return [Wavefront::Response]
+    #
+    def revoke(permission, roles)
+      wf_permission?(permission)
+      validate_role_list(roles)
+      api.post(['revoke', permission].uri_concat, roles, 'application/json')
+    end
+  end
+end

data/lib/wavefront-sdk/spy.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require_relative 'defs/constants'
+require_relative 'core/api'
+
+module Wavefront
+  #
+  # Spy on data going into Wavefront
+  #
+  class Spy < CoreApi
+    # GET /api/spy/points
+    # Gets new metric data points that are added to existing time series.
+    # @param sampling [Float] the amount of points to sample, from 0
+    #   (none) to 1 (all)
+    # @param filter [Hash] with the following keys:
+    #   :prefix [String] only list points whose metric name begins with this
+    #     case-sensitive string
+    #   :host [Array] only list points if source name begins with this
+    #     case-sensitive string
+    #   :tag_key [String,Array[String]] only list points with one or more of
+    #     the given points tags
+    # @param options [Hash] with the following keys
+    #   :timestamp [Boolean] prefix each block of streamed data with a
+    #     timestamp
+    #   :timeout [Integer] how many seconds to run the spy. After this time
+    #     the method returns
+    # @raise Wavefront::Exception::InvalidSamplingValue
+    # @return [Nil]
+    #
+    def points(sampling = 0.01, filters = {}, options = {})
+      wf_sampling_value?(sampling)
+      api.get_stream('points', points_filter(sampling, filters), options)
+    end
+
+    # GET /api/spy/histograms
+    # Gets new histograms that are added to existing time series.
+    # @param sampling [Float] see #points
+    # @param filter [Hash] see #points
+    # @param options [Hash] see #points
+    # @raise Wavefront::Exception::InvalidSamplingValue
+    # @return [Nil]
+    #
+    def histograms(sampling = 0.01, filters = {}, options = {})
+      wf_sampling_value?(sampling)
+      api.get_stream('histograms',
+                     histograms_filter(sampling, filters),
+                     options)
+    end
+
+    # GET /api/spy/spans
+    # Gets new spans with existing source names and span tags.
+    # @param sampling [Float] see #points
+    # @param filter [Hash] see #points
+    # @param options [Hash] see #points
+    # @raise Wavefront::Exception::InvalidSamplingValue
+    # @return [Nil]
+    #
+    def spans(sampling = 0.01, filters = {}, options = {})
+      wf_sampling_value?(sampling)
+      api.get_stream('spans', spans_filter(sampling, filters), options)
+    end
+
+    # GET /api/spy/ids
+    # Gets newly allocated IDs that correspond to new metric names, source
+    # names, point tags, or span tags. A new ID generally indicates that a
+    # new time series has been introduced.
+    # @param sampling [Float] see #points
+    # @param filter [Hash] with keys:
+    #   :prefix [String] only list assignments whose metric name begins with
+    #     this case-sensitive string
+    #   :type [String] one of METRIC, SPAN, HOST or STRING
+    # @param options [Hash] see #points
+    #
+    def ids(sampling = 0.01, filters = {}, options = {})
+      wf_sampling_value?(sampling)
+      api.get_stream('ids', ids_filter(sampling, filters), options)
+    end
+
+    def api_path
+      '/api/spy'
+    end
+
+    # We have to try to make the response we get from the API look
+    # like the one we get from the public API. To begin with, it's
+    # nothing like it.
+    #
+    # This method must be public because a #respond_to? looks for
+    # it.
+    #
+    def _response_shim(resp, status)
+      { response: parse_response(resp),
+        status: { result: status == 200 ? 'OK' : 'ERROR',
+                  message: extract_api_message(status, resp),
+                  code: status } }.to_json
+    end
+
+    private
+
+    def points_filter(sampling, filters)
+      { metric: filters.fetch(:prefix, nil),
+        host: filters.fetch(:host, nil),
+        sampling: sampling,
+        pointTagKey: filters.fetch(:tag_key, nil) }.compact
+    end
+
+    def histograms_filter(sampling, filters)
+      { histogram: filters.fetch(:prefix, nil),
+        host: filters.fetch(:host, nil),
+        sampling: sampling,
+        histogramTagKey: filters.fetch(:tag_key, nil) }.compact
+    end
+
+    def spans_filter(sampling, filters)
+      { name: filters.fetch(:prefix, nil),
+        host: filters.fetch(:host, nil),
+        sampling: sampling,
+        spanTagKey: filters.fetch(:tag_key, nil) }.compact
+    end
+
+    def ids_filter(sampling, filters)
+      { name: filters.fetch(:prefix, nil),
+        type: filters.fetch(:type, nil),
+        sampling: sampling }.compact
+    end
+  end
+end

data/lib/wavefront-sdk/stdlib/array.rb

@@ -11,6 +11,6 @@ class Array
   # @return [String] a URI path
   #
   def uri_concat
-    join('/').squeeze('/').sub(%r{\/$}, '').sub(%r{\/\?}, '?')
+    join('/').squeeze('/').sub(%r{/$}, '').sub(%r{/\?}, '?')
   end
 end

data/lib/wavefront-sdk/user.rb

@@ -4,16 +4,33 @@ require_relative 'core/api'
 require_relative 'api_mixins/user'
 
 module Wavefront
+  #
+  # In line with the API changes in the 2020-06 release of Wavefront, this
+  # class has been deprecated.
+  #
+  # Please use Wavefront::Account to manage users.
+  #
+  # https://docs.wavefront.com/2020.06.x_release_notes.html
   #
   # Manage and query Wavefront users
   #
   class User < CoreApi
     include Wavefront::Mixin::User
 
+    def deprecation_warning
+      logger.log('Wavefront::User is deprecated and will be removed from the ' \
+               'next major release. Please use Wavefront::Account.', :warn)
+    end
+
+    def post_initialize(_creds, _opts)
+      deprecation_warning
+    end
+
     # GET /api/v2/user
     # Get all users.
     #
     def list
+      deprecation_warning
       api.get('')
     end
 
@@ -26,6 +43,7 @@ module Wavefront
     # @return [Wavefront::Response]
     #
     def create(body, send_email = false)
+      deprecation_warning
       raise ArgumentError unless body.is_a?(Hash)
 
       api.post("?sendEmail=#{send_email}", body, 'application/json')
@@ -38,6 +56,7 @@ module Wavefront
     # @return [Wavefront::Response]
     #
     def delete(id)
+      deprecation_warning
       wf_user_id?(id)
       api.delete(id)
     end
@@ -49,6 +68,7 @@ module Wavefront
     # @return [Wavefront::Response]
     #
     def describe(id)
+      deprecation_warning
       wf_user_id?(id)
       api.get(id)
     end
@@ -65,6 +85,7 @@ module Wavefront
     # @return [Wavefront::Response]
 
     def update(id, body, modify = true)
+      deprecation_warning
       wf_user_id?(id)
       raise ArgumentError unless body.is_a?(Hash)
 
@@ -82,6 +103,7 @@ module Wavefront
     # @return [Wavefront::Response]
     #
     def add_groups_to_user(id, group_list = [])
+      deprecation_warning
       wf_user_id?(id)
       validate_usergroup_list(group_list)
       api.post([id, 'addUserGroups'].uri_concat, group_list,
@@ -95,6 +117,7 @@ module Wavefront
     # @return [Wavefront::Response]
     #
     def remove_groups_from_user(id, group_list = [])
+      deprecation_warning
       wf_user_id?(id)
       validate_usergroup_list(group_list)
       api.post([id, 'removeUserGroups'].uri_concat, group_list,
@@ -116,6 +139,7 @@ module Wavefront
     # @return [Wavefront::Response]
     #
     def grant(id, pgroup)
+      deprecation_warning
       wf_user_id?(id)
       raise ArgumentError unless pgroup.is_a?(String)
 
@@ -133,6 +157,7 @@ module Wavefront
     # @return [Wavefront::Response]
     #
     def revoke(id, pgroup)
+      deprecation_warning
       wf_user_id?(id)
       raise ArgumentError unless pgroup.is_a?(String)
 
@@ -149,6 +174,7 @@ module Wavefront
     # @return [Wavefront::Response]
     #
     def delete_users(user_list)
+      deprecation_warning
       raise ArgumentError unless user_list.is_a?(Array)
 
       validate_user_list(user_list)
@@ -165,6 +191,7 @@ module Wavefront
     # @return [Wavefront::Response]
     #
     def grant_permission(permission, user_list)
+      deprecation_warning
       raise ArgumentError unless user_list.is_a?(Array)
 
       validate_user_list(user_list)
@@ -182,6 +209,7 @@ module Wavefront
     # @return [Wavefront::Response]
     #
     def revoke_permission(permission, user_list)
+      deprecation_warning
       raise ArgumentError unless user_list.is_a?(Array)
 
       validate_user_list(user_list)
@@ -196,6 +224,7 @@ module Wavefront
     # @return [Wavefront::Response]
     #
     def invite(body)
+      deprecation_warning
       raise ArgumentError unless body.is_a?(Array)
       raise ArgumentError unless body.first.is_a?(Hash)
 
@@ -208,6 +237,7 @@ module Wavefront
     # @return [Wavefront::Response]
     #
     def business_functions(id)
+      deprecation_warning
       wf_user_id?(id)
       api.get([id, 'businessFunctions'].uri_concat)
     end
@@ -219,6 +249,7 @@ module Wavefront
     # @return [Wavefront::Response]
     #
     def validate_users(id_list)
+      deprecation_warning
       api.post('validateUsers', id_list, 'application/json')
     end
 

data/lib/wavefront-sdk/usergroup.rb

@@ -108,30 +108,31 @@ module Wavefront
                'application/json')
     end
 
-    # POST /api/v2/usergroup/grant/{permission}
-    # Grants a single permission to user group(s)
+    # POST /api/v2/usergroup/{id}/addRoles
+    # Add multiple roles to a specific user group
     #
-    # @param perm [String] permission to grant
-    # @param group_list [Array[String]] list of groups who should
-    #   receive permission
+    # @param id [String] ID of the user group
+    # @param role_list [Array[String]] list of roles to add
     # @return [Wavefront::Response]
     #
-    def grant(perm, group_list = [])
-      validate_usergroup_list(group_list)
-      api.post(['grant', perm].uri_concat, group_list, 'application/json')
+    def add_roles_to_group(id, role_list = [])
+      wf_usergroup_id?(id)
+      validate_role_list(role_list)
+      api.post([id, 'addRoles'].uri_concat, role_list, 'application/json')
     end
 
-    # POST /api/v2/usergroup/revoke/{permission}
-    # Revokes a single permission from user group(s)
+    # POST /api/v2/usergroup/{id}/removeRoles
+    # Remove multiple roles from a specific user group
     #
-    # @param perm [String] permission to revoke
-    # @param group_list [Array[String]] list of groups who should
-    #   lose permission
+    # @param id [String] ID of the user group
+    # @param user_list [Array[String]] list of roles to remove
     # @return [Wavefront::Response]
     #
-    def revoke(perm, group_list = [])
-      validate_usergroup_list(group_list)
-      api.post(['revoke', perm].uri_concat, group_list, 'application/json')
+    def remove_roles_from_group(id, role_list = [])
+      wf_usergroup_id?(id)
+      validate_role_list(role_list)
+      api.post([id, 'removeRoles'].uri_concat, role_list,
+               'application/json')
     end
   end
 end