wavefront-sdk 0.0.1

data/lib/wavefront-sdk/response.rb

@@ -0,0 +1,56 @@
+require 'json'
+require_relative './exception'
+
+module Wavefront
+
+  # Every API path has its own response class, which allows us to
+  # provide a stable interface. If the API changes underneath us,
+  # the SDK will break in a predictable way, throwing a
+  # Wavefront::Exception::InvalidResponse exception.
+  #
+  # Most Wavefront::Response classes present the returned data in
+  # two parts, each accessible by dot notation.
+  #   #status is the status object, which normally contains
+  #   'result', 'message', and 'code'. It is a struct.
+  #  #response contains the JSON response body, turned into a Ruby
+  #  hash.
+  #
+  class Response
+    class Base
+      attr_reader :status, :response, :debug
+
+      # Create and return a Wavefront::Response object
+      # @param json [String] a raw response body from the Wavefront API
+      # @param status [Integer] HTTP return code from the API
+      # @param debug [Boolean] whether or not to print the exception
+      #   message if one is thrown
+      # @raise Wavefront::InvalidResponse if the response cannot be
+      #   parsed
+      # @return a Wavefront::Response object
+      #
+      def initialize(json, status, debug = false)
+        @debug = debug
+        populate(JSON.parse(json, symbolize_names: true), status)
+      rescue => e
+        puts e.message if debug
+        raise Wavefront::Exception::InvalidResponse
+      end
+
+      def populate(raw, _status = 200)
+        if raw.key?(:status)
+          @status = Struct.new(*raw[:status].keys).
+            new(*raw[:status].values).freeze
+        end
+
+        if raw.key?(:response)
+          if raw[:response].key?(:items)
+            @response = Struct.new(*raw[:response].keys).
+              new(*raw[:response].values).freeze
+          else
+            @response = raw[:response]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wavefront-sdk/savedsearch.rb

@@ -0,0 +1,88 @@
+require_relative './base'
+
+module Wavefront
+  #
+  # View and manage Cloud Integrations. These are identified by
+  # a UUID.
+  #
+  class SavedSearch < Wavefront::Base
+
+    # GET /api/v2/savedsearch
+    # Get all saved searches for a user.
+    #
+    # @param offset [Int] saved search at which the list begins
+    # @param limit [Int] the number of saved searches to return
+    # @return [Hash]
+    #
+    def list(offset = 0, limit = 100)
+      api_get('', { offset: offset, limit: limit })
+    end
+
+    # POST /api/v2/savedsearch
+    # Create a saved search. Refer to the Swagger API docs for
+    # valid keys.
+    #
+    # @param body [Hash] description of saved search
+    # @return [Hash]
+    #
+    def create(body)
+      raise ArgumentError unless body.is_a?(Hash)
+      api_post('', body, 'application/json')
+    end
+
+    # DELETE /api/v2/savedsearch/{id}
+    # Delete a specific saved search.
+    #
+    # @param id [String] ID of the saved search
+    # @return [Hash]
+    #
+    def delete(id)
+      wf_savedsearch_id?(id)
+      api_delete(id)
+    end
+
+    # GET /api/v2/savedsearch/{id}
+    # Get a specific saved search.
+    #
+    # @param id [String] ID of the saved search
+    # @return [Hash]
+    #
+    def describe(id)
+      wf_savedsearch_id?(id)
+      api_get(id)
+    end
+
+    # PUT /api/v2/savedsearch/{id}
+    # Update a specific saved search.
+    #
+    # @param id [String] ID of the saved search
+    # @param body [Hash] description of saved search
+    #
+    def update(id, body)
+      wf_savedsearch_id?(id)
+      raise ArgumentError unless body.is_a?(Hash)
+      api_put(id, body)
+    end
+
+    # GET /api/v2/savedsearch/type/{entitytype}
+    # Get all saved searches for a specific entity type for a user.
+    #
+    # @param entitytype [String] type of entity to retrieve
+    # @param offset [Int] saved search at which the list begins
+    # @param limit [Int] the number of saved searches to return
+    # @return [Hash]
+    #
+    def entity(entitytype, offset = 0, limit = 100)
+      wf_savedsearch_entity?(entitytype)
+      api_get(['type', entitytype].uri_concat, { offset: offset,
+                                                 limit: limit })
+
+    end
+  end
+
+  # A standard response
+  #
+  class Response
+    class SavedSearch < Base; end
+  end
+end

data/lib/wavefront-sdk/search.rb

@@ -0,0 +1,58 @@
+require_relative './base'
+
+module Wavefront
+  #
+  # Manage and query Wavefront searches. The /search API path has a
+  # lot of paths, with a lot of duplication. The current state of
+  # this class covers the whole API with two methods, but leaves a
+  # lot up to the user. It may grow, with convenience methods.
+  #
+  class Search < Wavefront::Base
+
+    # POST /api/v2/search/agent
+    # POST /api/v2/search/agent/deleted
+    # Run a search query. This single method maps to many API paths.
+    #
+    # @param entity [String] the type of Wavefront object you wish
+    #   to search
+    # @param body [Hash] the query to use for searching. Refer to
+    #   the Wavefront Swagger docs for the correct format.
+    # @param deleted [Boolean] whether to search deleted (true) or
+    #   active (false) entities
+    #
+    def search(entity = nil, body = nil, deleted = false)
+      raise ArgumentError unless entity.is_a?(String)
+      raise ArgumentError unless body.is_a?(Hash)
+      path = ['agent']
+      path.<< 'deleted' if deleted
+      api_post(path, body, 'application/json')
+    end
+
+    # @param entity [String] the type of Wavefront object you wish
+    #   to search
+    # @param body [Hash] the query to use for searching. Refer to
+    #   the Wavefront Swagger docs for the correct format.
+    # @param deleted [Boolean] whether to search deleted (true) or
+    #   active (false) entities
+    # @param facet [String] the facet on which to search. If this is
+    #   false, the assumption is that multiple facets will be
+    #   specified in the body. See the Swagger docs for more
+    #   information.
+    #
+    def facet_search(entity = nil, body = nil, deleted = false,
+                     facet = false)
+      raise ArgumentError unless entity.is_a?(String)
+      raise ArgumentError unless body.is_a?(Hash)
+      path = ['agent']
+      path.<< 'deleted' if deleted
+      path.<< facet ? facet : 'facets'
+      api_post(path, body, 'application/json')
+    end
+  end
+
+  # A standard response
+  #
+  class Response
+    class Search < Base; end
+  end
+end

data/lib/wavefront-sdk/source.rb

@@ -0,0 +1,131 @@
+require_relative './base'
+
+module Wavefront
+  #
+  # View and manage source metadata.
+  #
+  class Source < Wavefront::Base
+
+    # GET /api/v2/source
+    # Get all sources for a customer
+    #
+    # @param offset [Int] source at which the list begins
+    # @param limit [Int] the number of sources to return
+    # @return [Hash]
+    #
+    def list(offset = 0, limit = 100)
+      api_get('', { offset: offset, limit: limit })
+    end
+
+    # POST /api/v2/source
+    # Create metadata (description or tags) for a specific source.
+    #
+    # Refer to the Swagger API docs for valid keys.
+    #
+    # @param body [Hash] description of source
+    # @return [Hash]
+    #
+    def create(body)
+      raise ArgumentError unless body.is_a?(Hash)
+      api_post('', body, 'application/json')
+    end
+
+    # DELETE /api/v2/source/{id}
+    # Delete metadata (description and tags) for a specific source.
+    #
+    # @param id [String] ID of the source
+    # @return [Hash]
+    #
+    def delete(id)
+      wf_source_id?(id)
+      api_delete(id)
+    end
+
+    # GET /api/v2/source/{id}
+    # Get a specific source for a customer.
+    #
+    # @param id [String] ID of the source
+    # @return [Hash]
+    #
+    def describe(id, version = nil)
+      wf_source_id?(id)
+      wf_version?(version) if version
+      fragments = [id]
+      fragments += ['history', version] if version
+      api_get(fragments.uri_concat)
+    end
+
+    # PUT /api/v2/source/{id}
+    # Update metadata (description or tags) for a specific source.
+    #
+    # Refer to the Swagger API docs for valid keys.
+    #
+    # @param body [Hash] description of source
+    # @return [Hash]
+    #
+    def update(id, body)
+      wf_source_id?(id)
+      raise ArgumentError unless body.is_a?(Hash)
+      api_put(id, body)
+    end
+
+    # GET /api/v2/source/{id}/tag
+    # Get all tags associated with a specific source.
+    #
+    # @param id [String] ID of the source
+    # @returns [Hash] object describing the source with status and
+    #   response keys
+    #
+    def tags(id)
+      wf_source_id?(id)
+      api_get([id, 'tag'].uri_concat)
+    end
+
+    # POST /api/v2/source/{id}/tag
+    # Set all tags associated with a specific source.
+    #
+    # @param id [String] ID of the source
+    # @param tags [Array] list of tags to set.
+    # @returns [Hash] object describing the source with status and
+    #   response keys
+    #
+    def tag_set(id, tags)
+      wf_source_id?(id)
+      tags = Array(tags)
+      tags.each { |t| wf_string?(t) }
+      api_post([id, 'tag'].uri_concat, tags.to_json, 'application/json')
+    end
+
+    # DELETE /api/v2/source/{id}/tag/{tagValue}
+    # Remove a tag from a specific source.
+    #
+    # @param id [String] ID of the source
+    # @param tag [String] tag to delete
+    # @returns [Hash] object with 'status' key and empty 'repsonse'
+    #
+    def tag_delete(id, tag)
+      wf_source_id?(id)
+      wf_string?(tag)
+      api_delete([id, 'tag', tag].uri_concat)
+    end
+
+    # PUT /api/v2/source/{id}/tag/{tagValue}
+    # Add a tag to a specific source
+    #
+    # @param id [String] ID of the source
+    # @param tag [String] tag to set.
+    # @returns [Hash] object with 'status' key and empty 'repsonse'
+    #
+    def tag_add(id, tag)
+      wf_source_id?(id)
+      wf_string?(tag)
+      api_put([id, 'tag', tag].uri_concat)
+    end
+  end
+
+  # A standard response
+  #
+  class Response
+    class Source < Base; end
+  end
+end

data/lib/wavefront-sdk/user.rb

@@ -0,0 +1,108 @@
+require_relative './base'
+
+module Wavefront
+  #
+  # Manage and query Wavefront users
+  #
+  class User < Wavefront::Base
+
+    # GET /api/v2/user
+    # Get all users.
+    #
+    def list
+      api_get('')
+    end
+
+    # POST /api/v2/user
+    # Creates or updates a user
+    #
+    # @param body [Hash] a hash of parameters describing the user.
+    #   Please refer to the Wavefront Swagger docs for key:value
+    #   information
+    # @return [Hash]
+    #
+    def create(body, send_email = false)
+      raise ArgumentError unless body.is_a?(Hash)
+      api_post("?sendEmail=#{send_email}", body, 'application/json')
+    end
+
+    # DELETE /api/v2/user/{id}
+    # Delete a specific user.
+    #
+    # @param id [String] ID of the user
+    # @return [Hash]
+    #
+    def delete(id)
+      wf_user_id?(id)
+      api_delete(id)
+    end
+
+    # GET /api/v2/user/{id}
+    # Retrieves a user by identifier (email addr).
+    #
+    # @param id [String] ID of the user
+    # @return [Hash]
+    #
+    def describe(id)
+      wf_user_id?(id)
+      api_get(id)
+    end
+
+    # PUT /api/v2/user/{id}/grant
+    # Grants a specific user permission.
+    #
+    # @param id [String] ID of the user
+    # @param group [String] group to add user to. We do not validate
+    #   this so that changes to the API do not mandate changes to
+    #   the SDK. At the time of writing, valid values are browse,
+    #   agent_management, alerts_management, dashboard_management,
+    #   embedded_charts, events_management,
+    #   external_links_management, host_tag_management,
+    #   metrics_management, user_management,
+    # @return [Hash]
+    #
+    def grant(id, group)
+      wf_user_id?(id)
+      raise ArgumentError unless group.is_a?(String)
+      api_post([id, 'grant'].uri_concat, "group=#{group}",
+               'application/x-www-form-urlencoded')
+    end
+
+    # PUT /api/v2/user/{id}/revoke
+    # Revokes a specific user permission.
+    #
+    # @param id [String] ID of the user
+    # @param group [String] group to add user to. We do not validate
+    #   this so that changes to the API do not mandate changes to
+    #   the SDK. See #update for valid values.
+    # @return [Hash]
+    #
+    def revoke(id, group)
+      wf_user_id?(id)
+      raise ArgumentError unless group.is_a?(String)
+      api_post([id, 'revoke'].uri_concat, "group=#{group}",
+               'application/x-www-form-urlencoded')
+    end
+  end
+
+  class Response
+
+    # The User response forges status and response methods to look
+    # like other classes and create a more consistent interface.
+    #
+    class User < Base
+      def populate(raw, status)
+        @response = if raw.is_a?(Array)
+                      Struct.new(:items).new(raw).freeze
+                    elsif raw.is_a?(Hash)
+                      Struct.new(*raw.keys).new(*raw.values).freeze
+                    end
+
+        result = status == 200 ? 'OK' : 'ERROR'
+
+        @status = Struct.new(:result, :message, :code).
+            new(result, nil, status)
+      end
+    end
+  end
+end

data/lib/wavefront-sdk/validators.rb

@@ -0,0 +1,395 @@
+require_relative './exception'
+
+module Wavefront
+  #
+  # A module of mixins to validate input. The Wavefront documentation
+  # lays down restrictions on types and sizes of various inputs, which
+  # we will check on the user's behalf. Most of the information used in
+  # this file comes from https://community.wavefront.com/docs/DOC-1031
+  # Some comes from the Swagger API documentation, some has come
+  # directly from Wavefront engineers.
+  #
+  module Validators
+
+    # Ensure the given argument is a valid external link template
+    #
+    # @return true if it is valid
+    # @raise Wavefront::Exception::InvalidTemplate if not
+    #
+    def wf_link_template?(v)
+      if v.is_a?(String) && (v.start_with?('http://') ||
+                             v.start_with?('https://'))
+        return true
+      end
+
+      raise Wavefront::Exception::InvalidLinkTemplate
+    end
+
+    # Ensure the given argument is a valid Wavefront metric name, or
+    # path.
+    #
+    # @param v [String] the metric name to validate
+    # @return True if the metric name is valid
+    # @raise Wavefront::Exception::InvalidMetricName if metric name
+    # is not valid.
+    #
+    def wf_metric_name?(v)
+      if v.is_a?(String) && v.size < 1024 &&
+         (v.match(/^[\w\-\.]+$/) || v.match(%r{^\"[\w\-\.\/,]+\"$}))
+        return true
+      end
+
+      raise Wavefront::Exception::InvalidMetricName
+    end
+
+    # Ensure the given argument is a valid name, for instance for an
+    # event. Names can contain, AFAIK, word characters.
+    #
+    # @param v [String] the name to validate
+    # @return true if the name is valid
+    # raise Wavefront::Exception::InvalidName if name is not valid
+    #
+    def wf_name?(v)
+      return true if v.is_a?(String) && v.size < 1024 && v =~ /^\w+$/
+      raise Wavefront::Exception::InvalidName
+    end
+
+    # Ensure the given argument is a valid string, for a tag name.
+    #
+    # @param v [String] the string name to validate
+    # @return True if the string is valid
+    # @raise Wavefront::Exception::InvalidString if string is not valid.
+    #
+    def wf_string?(v)
+      #
+      # Only allows PCRE "word" characters, spaces, full-stops and
+      # commas in tags and descriptions. This might be too restrictive,
+      # but if it is, this is the only place we need to change it.
+      #
+      return true if v.is_a?(String) && v.size < 1024 && v =~ /^[\-\w \.,]*$/
+
+      raise Wavefront::Exception::InvalidString
+    end
+
+    # Ensure the given argument is a valid timestamp
+    #
+    # @param v [DateTime] the timestamp name to validate
+    # @return True if the value is valid
+    # @raise Wavefront::Exception::InvalidTimestamp
+    #
+    def wf_ts?(v)
+      return true if v.is_a?(Time) || v.is_a?(Date)
+      raise Wavefront::Exception::InvalidTimestamp
+    end
+
+    # Ensure the given argument is a valid millisecond epoch
+    # timestamp. We do no checking of the value, because who am I to
+    # say that the user doesn't want to send a point relating to 1ms
+    # after the epoch, or a thousand years in the future?
+    #
+    # @param v [Integer] the timestamp name to validate
+    # @return True if the value is valid
+    # @raise Wavefront::Exception::InvalidTimestamp
+    #
+    def wf_ms_ts?(v)
+      return true if v.is_a?(Numeric)
+      raise Wavefront::Exception::InvalidTimestamp
+    end
+
+    # Ensure the given argument is a valid epoch timestamp. Again,
+    # no range checking.
+    #
+    # @param v [String, Integer]
+    # @return True if the timestamp is valid
+    # @raise Wavefront::Exception::InvalidMaintenanceWindow
+    #
+    def wf_epoch?(v)
+      return true if v.is_a?(Numeric)
+      raise Wavefront::Exception::InvalidTimestamp
+    end
+
+    # Ensure one, or an array, of tags are valid. These tags are
+    # used as source tags, or tags for maintenance windows etc. They
+    # can contain letters, numbers, -, _ and :, and must be less
+    # than 256 characters long
+    #
+    # @param v [String, Array] a tag or list of tags
+    # @return True if all tags are valid
+    # @raise Wavefront::Exception::InvalidTag
+    #
+    def wf_tag?(*v)
+      Array(*v).each do |t|
+        unless t.is_a?(String) && t.size < 255 && t =~ /^[\w:\-\.]+$/
+          raise Wavefront::Exception::InvalidTag
+        end
+      end
+
+      true
+    end
+
+    # Ensure the given argument is a valid Wavefront value. Can be
+    # any form of Numeric, including standard notation.
+    #
+    # @param v [Numeric] the source name to validate
+    # @return True if the value is valid
+    # @raise Wavefront::Exception::InvalidValue if the value is not valid
+    #
+    def wf_value?(v)
+      return true if v.is_a?(Numeric)
+      raise Wavefront::Exception::InvalidMetricValue
+    end
+
+    # Ensure the given argument is a valid version number
+    #
+    # @param [Integer] the version number to validate
+    # @return True if the version is valid
+    # @raise Wavefront::Exception::InvalidVersion if the alert ID is
+    #   not valid
+    #
+    def wf_version?(v)
+      v = v.to_i if v.is_a?(String) && v =~ /^\d+$/
+      return true if v.is_a?(Integer) && v > 0
+      raise Wavefront::Exception::InvalidVersion
+    end
+
+    # Ensure a hash of key:value point tags are value. Not to be
+    # confused with source tags.
+    #
+    # @param tags [Hash] a hash of key:value tags
+    # @return True if all tags are valid
+    # @raise Wavefront::Exception::InvalidTag if any tags in the has
+    #   do not validate
+    #
+    def wf_point_tags?(tags)
+      raise Wavefront::Exception::InvalidTag unless tags.is_a?(Hash)
+
+      tags.each do |k, v|
+        unless (k.size + v.size < 254) && k.match(/^[\w\-\.:]+$/)
+          raise Wavefront::Exception::InvalidTag
+        end
+      end
+      true
+    end
+
+    # Ensure the given argument is a valid Wavefront proxy ID
+    #
+    # @param v [String] the proxy ID to validate
+    # @return True if the proxy ID is valid
+    # @raise Wavefront::Exception::InvalidProxyId if the proxy ID
+    #   is not valid
+    #
+    def wf_proxy_id?(v)
+      if v.is_a?(String) && v.match(
+        /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/
+      )
+        return true
+      end
+
+      raise Wavefront::Exception::InvalidProxyId
+    end
+
+    # Ensure the given argument is a valid Wavefront alert ID.
+    # Alerts are identified by the epoch-nanosecond at which they
+    # were created.
+    #
+    # @param v [String] the alert ID to validate
+    # @return True if the alert ID is valid
+    # @raise Wavefront::Exception::InvalidAlertId if the alert ID is
+    #   not valid
+    #
+    def wf_alert_id?(v)
+      v = v.to_s if v.is_a?(Numeric)
+      return true if v.is_a?(String) && v.match(/^\d{13}$/)
+      raise Wavefront::Exception::InvalidAlertId
+    end
+
+    # Ensure the given argument is a valid Wavefront cloud
+    # integration ID
+    #
+    # @param v [String] the integration name to validate
+    # @return True if the integration name is valid
+    # @raise Wavefront::Exception::InvalidCloudIntegrationId if the
+    #   integration ID is not valid
+    #
+    def wf_cloudintegration_id?(v)
+      if v.is_a?(String) && v.match(
+        /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/
+      )
+        return true
+      end
+
+      raise Wavefront::Exception::InvalidCloudIntegrationId
+    end
+
+    # There doesn't seem to be a public statement on what's allowed
+    # in a dashboard name. For now I'm going to assume up to 255 word
+    # characters.
+    #
+    # @param v [String] the dashboard ID to validate
+    # @return true if the dashboard ID is valid
+    # @raise Wavefront::Exception::InvalidDashboardID if the
+    #   dashboard ID is not valid
+    #
+    def wf_dashboard_id?(v)
+      return true if v.is_a?(String) && v.size < 256 && v.match(/^[\w\-]+$/)
+      raise Wavefront::Exception::InvalidDashboardId
+    end
+
+    # Ensure the given argument is a valid event ID. Event IDs are
+    # an epoch-millisecond timestamp followed by a : followed by the
+    # name of the event.
+    #
+    # @param v [String] the event ID to validate
+    # @return true if the event ID is valid
+    # @raise Wavefront::Exception::InvalidEventID if the
+    #   event ID is not valid
+    #
+    def wf_event_id?(v)
+      return true if v.is_a?(String) && v =~ /^\d{13}:[\w\- ]+$/
+      raise Wavefront::Exception::InvalidEventId
+    end
+
+    # Ensure the given argument is a valid external Link ID
+    #
+    # @param v [String] the external link ID to validate
+    # @return True if the link ID is valid
+    # @raise Wavefront::Exception::InvalidExternalLinkId if the
+    #   link ID is not valid
+    #
+    def wf_link_id?(v)
+      return true if v.is_a?(String) && v =~ /^\w{16}$/
+      raise Wavefront::Exception::InvalidExternalLinkId
+    end
+
+    # Ensure the given argument is a valid maintenance window ID.
+    # IDs are the millisecond epoch timestamp at which the window
+    # was created.
+    #
+    # @param v [String, Integer]
+    # @return True if the ID is valid
+    # @raise Wavefront::Exception::InvalidMaintenanceWindowId
+    #
+    def wf_maintenance_window_id?(v)
+      v = v.to_s if v.is_a?(Numeric)
+      return true if v.is_a?(String) && v =~ /^\d{13}$/
+
+      raise Wavefront::Exception::InvalidMaintenanceWindowId
+    end
+
+    # Ensure the given argument is a valid alert severity
+    #
+    # @param v [String] severity
+    # @return true if valid
+    # @raise Wavefront::Exceptions::InvalidAlertSeverity if not
+    #   valid
+    #
+    def wf_alert_severity?(v)
+      return true if %w(INFO SMOKE WARN SEVERE).include?(v)
+      raise Wavefront::Exception::InvalidAlertSeverity
+    end
+
+    # Ensure the given argument is a valid message ID
+    #
+    # @param v [String] severity
+    # @return true if valid
+    # @raise Wavefront::Exceptions::InvalidMessageId if not
+    #   valid
+    #
+    def wf_message_id?(v)
+      return true if v.is_a?(String) && v =~ /^\w+$/
+      raise Wavefront::Exception::InvalidMessageId
+    end
+
+    # Ensure the given argument is a valid query granularity
+    #
+    # @param v [String] granularity
+    # @return true if valid
+    # @raise Wavefront::Exceptions::InvalidGranularity if not
+    #   valid
+    #
+    def wf_granularity?(v)
+      return true if %w(d h m s).include?(v.to_s)
+      raise Wavefront::Exception::InvalidGranularity
+    end
+
+    # Ensure the given argument is a valid saved search ID.
+    #
+    # @param v [String] saved search ID
+    # @return true if valid
+    # @raise Wavefront::Exceptions::InvalidSavedSearchId if not valid
+    #
+    def wf_savedsearch_id?(v)
+      return true if v.is_a?(String) && v =~ /^\w{8}$/
+      raise Wavefront::Exception::InvalidSavedSearchId
+    end
+
+    # Ensure the given argument is a valid saved search entity type.
+    #
+    # @param v [String] entity type
+    # @return true if valid
+    # @raise Wavefront::Exceptions::InvalidSavedSearchEntity if not
+    #   valid
+    #
+    def wf_savedsearch_entity?(v)
+      return true if %w(DASHBOARD ALERT MAINTENANCE_WINDOW
+                        NOTIFICANT EVENT SOURCE EXTERNAL_LINK AGENT
+                        CLOUD_INTEGRATION).include?(v)
+      raise Wavefront::Exception::InvalidSavedSearchEntity
+    end
+
+    # Ensure the given argument is a valid Wavefront source name
+    #
+    # @param v [String] the source name to validate
+    # @return True if the source name is valid
+    # @raise Wavefront::Exception::InvalidSourceId if the source name
+    #   is not valid
+    #
+    def wf_source_id?(v)
+      if v.is_a?(String) && v.match(/^[\w\.\-]+$/) && v.size < 1024
+        return true
+      end
+
+      raise Wavefront::Exception::InvalidSourceId
+    end
+
+    # Ensure the given argument is a valid user.
+    #
+    # @param v [String] user identifier
+    # @return true if valid
+    # @raise Wavefront::Exceptions::InvalidUserId if not valid
+    #
+    def wf_user_id?(v)
+      return true if v.is_a?(String) &&
+         v =~ /\A([\w+\-].?)+@[a-z\d\-]+(\.[a-z]+)*\.[a-z]+\z/i
+      raise Wavefront::Exception::InvalidUserId
+    end
+
+    # Ensure the given argument is a valid webhook ID.
+    #
+    # @param v [String] webhook ID
+    # @return true if valid
+    # @raise Wavefront::Exceptions::InvalidWebhook if not valid
+    #
+    def wf_webhook_id?(v)
+      return true if v.is_a?(String) && v =~ /^[a-zA-Z0-9]{16}$/
+      raise Wavefront::Exception::InvalidWebhookId
+    end
+
+    # Validate a point so it conforms to the standard described in
+    # https://community.wavefront.com/docs/DOC-1031
+    #
+    # @param v [Hash] description of point
+    # @return true if valie
+    # @raise whichever exception is thrown first when validating
+    #   each component of the point.
+    #
+    def wf_point?(v)
+      wf_metric_name?(v[:path])
+      wf_value?(v[:value])
+      wf_epoch?(v[:ts]) if v[:ts]
+      wf_source_id?(v[:source]) if v[:source]
+      wf_point_tags?(v[:tags]) if v[:tags]
+      true
+    end
+  end
+end