wavefront-sdk 1.6.0 → 1.6.1

data/lib/wavefront-sdk/response.rb

@@ -1,8 +1,10 @@
 require 'json'
 require 'map'
 require_relative 'exception'
+require_relative 'mixins'
 
 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
@@ -18,31 +20,36 @@ module Wavefront
   #     which  allows
   #
   class Response
-    attr_reader :status, :response
+    include Wavefront::Mixins
+    attr_reader :status, :response, :opts, :logger
 
     # 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
+    # @param opts [Hash] options passed through from calling class.
     # @raise [Wavefront::Exception::UnparseableResponse] if the
     #   response cannot be parsed. This may be because the API
     #   has changed underneath us.
     #
-    # rubocop:disable Metrics/CyclomaticComplexity
-    # rubocop:disable Metrics/PerceivedComplexity
-    def initialize(json, status, debug = false)
-      raw = raw_response(json, status)
-      @status = build_status(raw, status)
+    def initialize(json, status, opts = {})
+      raw       = raw_response(json, status)
+      @status   = build_status(raw, status)
       @response = build_response(raw)
+      @opts     = opts
+
+      setup_opts
 
-      p self if debug
+      logger.log(self, :debug)
     rescue StandardError => e
-      puts "could not parse:\n#{json}" if debug
-      puts e.message if debug
+      logger.log(format("could not parse:\n%s", json), :debug)
+      logger.log(e.message.to_s, :debug)
       raise Wavefront::Exception::UnparseableResponse
     end
 
+    def setup_opts
+      @logger = Wavefront::Logger.new(opts)
+    end
+
     def raw_response(json, status)
       json.empty? ? {} : JSON.parse(json, symbolize_names: true)
     rescue StandardError
@@ -61,7 +68,7 @@ module Wavefront
     end
   end
 
-  # Status tests
+  # Status types are used by the Wavefront::Response class
   #
   class Type
     #
@@ -79,24 +86,28 @@ module Wavefront
     #     request
     #
     class Status
-      attr_reader :result, :message, :code
+      attr_reader :obj, :status
 
-      # @param raw [Hash] the API response, turned into a hash
+      # @param response [Hash] the API response, turned into a hash
       # @param status [Integer] HTTP status code
       #
-      def initialize(raw, status)
-        obj = raw.key?(:status) ? raw[:status] : raw
+      def initialize(response, status)
+        @obj = response.fetch(:status, response)
+        @status = status
+      end
+
+      def message
+        obj[:message] || nil
+      end
 
-        @message = obj[:message] || nil
-        @code = obj[:code] || status
+      def code
+        obj[:code] || status
+      end
 
-        @result = if obj[:result]
-                    obj[:result]
-                  elsif status >= 200 && status <= 299
-                    'OK'
-                  else
-                    'ERROR'
-                  end
+      def result
+        return obj[:result] if obj[:result]
+        return 'OK' if status.between?(200, 299)
+        'ERROR'
       end
     end
   end

data/lib/wavefront-sdk/search.rb

@@ -94,8 +94,8 @@ module Wavefront
     #
     def raw_facet_search(entity = nil, body = nil, deleted = false,
                          facet = false)
-      raise ArgumentError unless entity.is_a?(String)
-      raise ArgumentError unless body.is_a?(Hash)
+      raise ArgumentError unless entity.is_a?(String) && body.is_a?(Hash)
+
       path = [entity]
       path.<< 'deleted' if deleted
       path.<< facet ? facet : 'facets'

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

@@ -6,8 +6,13 @@ class Hash
   # Convert a tag hash into a string. The quoting is recommended in
   # the WF wire-format guide. No validation is performed here.
   #
-  # rubocop:disable Style/FormatStringToken
   def to_wf_tag
     map { |k, v| format('%s="%s"', k, v.tagescape) }.join(' ')
   end
+
+  # Drop any key-value pairs where the value is not truthy
+  #
+  def cleanse
+    select { |_k, v| v }
+  end
 end

data/lib/wavefront-sdk/validators.rb

@@ -1,4 +1,3 @@
-# rubocop:disable Naming/UncommunicativeMethodParamName
 require_relative 'constants'
 require_relative 'exception'
 
@@ -18,8 +17,11 @@ module Wavefront
     # @return true if it is valid
     # @raise Wavefront::Exception::InvalidTemplate if not
     #
-    def wf_link_template?(v)
-      return true if v.is_a?(String) && v.start_with?('http://', 'https://')
+    def wf_link_template?(template)
+      if template.is_a?(String) &&
+         template.start_with?('http://', 'https://')
+        return true
+      end
 
       raise Wavefront::Exception::InvalidLinkTemplate
     end
@@ -27,15 +29,15 @@ module Wavefront
     # Ensure the given argument is a valid Wavefront metric name, or
     # path.
     #
-    # @param v [String] the metric name to validate
+    # @param metric [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(/^#{DELTA}?[\w\-\.]+$/) ||
-          v.match(%r{^\"#{DELTA}?[\w\-\.\/,]+\"$}))
+    def wf_metric_name?(metric)
+      if metric.is_a?(String) && metric.size < 1024 &&
+         (metric.match(/^#{DELTA}?[\w\-\.]+$/) ||
+          metric.match(%r{^\"#{DELTA}?[\w\-\.\/,]+\"$}))
         return true
       end
 
@@ -45,40 +47,42 @@ module Wavefront
     # 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
+    # @param name [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+$/
+    def wf_name?(name)
+      return true if name.is_a?(String) && name.size < 1024 && name =~ /^\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
+    # @param str [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)
+    def wf_string?(str)
       #
       # 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 \.,]*$/
+      if str.is_a?(String) && str.size < 1024 && str =~ /^[\-\w \.,]*$/
+        return true
+      end
 
       raise Wavefront::Exception::InvalidString
     end
 
     # Ensure the given argument is a valid timestamp
     #
-    # @param v [DateTime] the timestamp name to validate
+    # @param timestamp [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)
+    def wf_ts?(timestamp)
+      return true if timestamp.is_a?(Time) || timestamp.is_a?(Date)
       raise Wavefront::Exception::InvalidTimestamp
     end
 
@@ -87,24 +91,24 @@ module Wavefront
     # 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
+    # @param timestamp [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)
+    def wf_ms_ts?(timestamp)
+      return true if timestamp.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]
+    # @param timestamp [String, Integer]
     # @return True if the timestamp is valid
     # @raise Wavefront::Exception::InvalidMaintenanceWindow
     #
-    def wf_epoch?(v)
-      return true if v.is_a?(Numeric)
+    def wf_epoch?(timestamp)
+      return true if timestamp.is_a?(Numeric)
       raise Wavefront::Exception::InvalidTimestamp
     end
 
@@ -113,13 +117,13 @@ module Wavefront
     # can contain letters, numbers, -, _ and :, and must be less
     # than 256 characters long
     #
-    # @param v [String, Array] a tag or list of tags
+    # @param tags [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:\-\.]+$/
+    def wf_tag?(*tags)
+      Array(*tags).each do |tag|
+        unless tag.is_a?(String) && tag.size < 255 && tag =~ /^[\w:\-\.]+$/
           raise Wavefront::Exception::InvalidTag
         end
       end
@@ -130,29 +134,27 @@ module Wavefront
     # 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
+    # @param value [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)
+    def wf_value?(value)
+      return true if value.is_a?(Numeric)
       raise Wavefront::Exception::InvalidMetricValue
     end
 
     # Ensure the given argument is a valid version number
     #
-    # @param v [Integer] the version number to validate
+    # @param version [Integer] the version number to validate
     # @return True if the version is valid
     # @raise Wavefront::Exception::InvalidVersion if the alert ID is
     #   not valid
     #
-    # rubocop:disable Style/NumericPredicate
-    def wf_version?(v)
-      v = v.to_i if v.is_a?(String) && v =~ /^\d+$/
-      return true if v.is_a?(Integer) && v > 0
+    def wf_version?(version)
+      version = version.to_i if version.is_a?(String) && version =~ /^\d+$/
+      return true if version.is_a?(Integer) && version > 0
       raise Wavefront::Exception::InvalidVersion
     end
-    # rubocop:enable Style/NumericPredicate
 
     # Ensure a hash of key:value point tags are value. Not to be
     # confused with source tags.
@@ -167,28 +169,30 @@ module Wavefront
       tags.each { |k, v| wf_point_tag?(k, v) }
     end
 
-    # Validate a single point tag, probably on behalf of
-    # #wf_point_tags?
-    # @param k [String] tag key
-    # @param v [String] tag value
+    # Validate a single point tag, probably on behalf of #wf_point_tags?
+    # @param key [String] tag key
+    # @param val [String] tag value
     # @raise Wavefront::Exception::InvalidTag if any tag is not valid
     # @return nil
     #
-    def wf_point_tag?(k, v)
-      return if k && v && (k.size + v.size < 254) && k =~ /^[\w\-\.:]+$/ &&
-                v !~ /\\$/
+    def wf_point_tag?(key, val)
+      if key && val && (key.size + val.size < 254) &&
+         key =~ /^[\w\-\.:]+$/ && val !~ /\\$/
+        return
+      end
+
       raise Wavefront::Exception::InvalidTag
     end
 
     # Ensure the given argument is a valid Wavefront proxy ID
     #
-    # @param v [String] the proxy ID to validate
+    # @param id [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(
+    def wf_proxy_id?(id)
+      if id.is_a?(String) && id.match(
         /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/
       )
         return true
@@ -201,27 +205,27 @@ module Wavefront
     # Alerts are identified by the epoch-nanosecond at which they
     # were created.
     #
-    # @param v [String] the alert ID to validate
+    # @param id [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}$/)
+    def wf_alert_id?(id)
+      id = id.to_s if id.is_a?(Numeric)
+      return true if id.is_a?(String) && id.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
+    # @param id [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(
+    def wf_cloudintegration_id?(id)
+      if id.is_a?(String) && id.match(
         /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/
       )
         return true
@@ -234,13 +238,13 @@ module Wavefront
     # in a dashboard name. For now I'm going to assume up to 255 word
     # characters.
     #
-    # @param v [String] the dashboard ID to validate
+    # @param id [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\-]+$/)
+    def wf_dashboard_id?(id)
+      return true if id.is_a?(String) && id.size < 256 && id.match(/^[\w\-]+$/)
       raise Wavefront::Exception::InvalidDashboardId
     end
 
@@ -248,13 +252,13 @@ module Wavefront
     # are the millisecond epoch timestamp at which the derived
     # metric was created.
     #
-    # @param v [String, Integer]
+    # @param id [String, Integer]
     # @return True if the ID is valid
     # @raise Wavefront::Exception::InvalidDerivedMetricId
     #
-    def wf_derivedmetric_id?(v)
-      v = v.to_s if v.is_a?(Numeric)
-      return true if v.is_a?(String) && v =~ /^\d{13}$/
+    def wf_derivedmetric_id?(id)
+      id = id.to_s if id.is_a?(Numeric)
+      return true if id.is_a?(String) && id =~ /^\d{13}$/
 
       raise Wavefront::Exception::InvalidDerivedMetricId
     end
@@ -263,25 +267,25 @@ module Wavefront
     # an epoch-millisecond timestamp followed by a : followed by the
     # name of the event.
     #
-    # @param v [String] the event ID to validate
+    # @param id [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}:.+/
+    def wf_event_id?(id)
+      return true if id.is_a?(String) && id =~ /^\d{13}:.+/
       raise Wavefront::Exception::InvalidEventId
     end
 
     # Ensure the given argument is a valid external Link ID
     #
-    # @param v [String] the external link ID to validate
+    # @param id [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}$/
+    def wf_link_id?(id)
+      return true if id.is_a?(String) && id =~ /^\w{16}$/
       raise Wavefront::Exception::InvalidExternalLinkId
     end
 
@@ -289,155 +293,159 @@ module Wavefront
     # IDs are the millisecond epoch timestamp at which the window
     # was created.
     #
-    # @param v [String, Integer]
+    # @param id [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}$/
+    def wf_maintenance_window_id?(id)
+      id = id.to_s if id.is_a?(Numeric)
+      return true if id.is_a?(String) && id =~ /^\d{13}$/
 
       raise Wavefront::Exception::InvalidMaintenanceWindowId
     end
 
     # Ensure the given argument is a valid alert severity
     #
-    # @param v [String] severity
+    # @param severity [String] severity
     # @return true if valid
-    # @raise Wavefront::Exceptions::InvalidAlertSeverity if not
-    #   valid
+    # @raise Wavefront::Exceptions::InvalidAlertSeverity if not valid
     #
-    def wf_alert_severity?(v)
-      return true if %w[INFO SMOKE WARN SEVERE].include?(v)
+    def wf_alert_severity?(severity)
+      return true if %w[INFO SMOKE WARN SEVERE].include?(severity)
       raise Wavefront::Exception::InvalidAlertSeverity
     end
 
     # Ensure the given argument is a valid message ID
     #
-    # @param v [String] severity
+    # @param id [String] message ID
     # @return true if valid
-    # @raise Wavefront::Exceptions::InvalidMessageId if not
-    #   valid
+    # @raise Wavefront::Exceptions::InvalidMessageId if not valid
     #
-    def wf_message_id?(v)
-      return true if v.is_a?(String) && v =~ /^\w+::\w+$/
+    def wf_message_id?(id)
+      return true if id.is_a?(String) && id =~ /^\w+::\w+$/
       raise Wavefront::Exception::InvalidMessageId
     end
 
     # Ensure the given argument is a valid query granularity
     #
-    # @param v [String] granularity
+    # @param granularity [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)
+    def wf_granularity?(granularity)
+      return true if %w[d h m s].include?(granularity.to_s)
       raise Wavefront::Exception::InvalidGranularity
     end
 
     # Ensure the given argument is a valid saved search ID.
     #
-    # @param v [String] saved search ID
+    # @param id [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}$/
+    def wf_savedsearch_id?(id)
+      return true if id.is_a?(String) && id =~ /^\w{8}$/
       raise Wavefront::Exception::InvalidSavedSearchId
     end
 
     # Ensure the given argument is a valid saved search entity type.
     #
-    # @param v [String] entity type
+    # @param id [String] entity type
     # @return true if valid
     # @raise Wavefront::Exceptions::InvalidSavedSearchEntity if not
     #   valid
     #
-    def wf_savedsearch_entity?(v)
+    def wf_savedsearch_entity?(id)
       return true if %w[DASHBOARD ALERT MAINTENANCE_WINDOW
                         NOTIFICANT EVENT SOURCE EXTERNAL_LINK AGENT
-                        CLOUD_INTEGRATION].include?(v)
+                        CLOUD_INTEGRATION].include?(id)
       raise Wavefront::Exception::InvalidSavedSearchEntity
     end
 
     # Ensure the given argument is a valid Wavefront source name
     #
-    # @param v [String] the source name to validate
+    # @param source [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)
-      return true if v.is_a?(String) && v.match(/^[\w\.\-]+$/) && v.size < 1024
+    def wf_source_id?(source)
+      if source.is_a?(String) && source.match(/^[\w\.\-]+$/) &&
+         source.size < 1024
+        return true
+      end
 
       raise Wavefront::Exception::InvalidSourceId
     end
 
     # Ensure the given argument is a valid user.
     #
-    # @param v [String] user identifier
+    # @param user [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
+    def wf_user_id?(user)
+      if user.is_a?(String) &&
+         user =~ /\A([\w+\-].?)+@[a-z\d\-]+(\.[a-z]+)*\.[a-z]+\z/i
+        return true
+      end
+
       raise Wavefront::Exception::InvalidUserId
     end
 
     # Ensure the given argument is a valid webhook ID.
     #
-    # @param v [String] webhook ID
+    # @param id [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}$/
+    def wf_webhook_id?(id)
+      return true if id.is_a?(String) && id =~ /^[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
+    # @param point [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]
+    def wf_point?(point)
+      wf_metric_name?(point[:path])
+      wf_value?(point[:value])
+      wf_epoch?(point[:ts]) if point[:ts]
+      wf_source_id?(point[:source]) if point[:source]
+      wf_point_tags?(point[:tags]) if point[:tags]
       true
     end
 
-    # Ensure the given argument is a valid Wavefront
-    # notificant ID.
+    # Ensure the given argument is a valid Wavefront notificant ID.
     #
-    # @param v [String] the notificant name to validate
-    # @return True if the notificant name is valid
+    # @param id [String] the notificant ID to validate
+    # @return True if the notificant ID is valid
     # @raise Wavefront::Exception::InvalidNotificantId if the
     #   notificant ID is not valid
     #
-    def wf_notificant_id?(v)
-      return true if v.is_a?(String) && v =~ /^\w{16}$/
+    def wf_notificant_id?(id)
+      return true if id.is_a?(String) && id =~ /^\w{16}$/
       raise Wavefront::Exception::InvalidNotificantId
     end
 
     # Ensure the given argument is a valid Wavefront
     # integration ID. These appear to be lower-case strings.
     #
-    # @param v [String] the integration name to validate
+    # @param id [String] the integration ID to validate
     # @return True if the integration name is valid
     # @raise Wavefront::Exception::InvalidIntegrationId if the
     #   integration ID is not valid
     #
-    def wf_integration_id?(v)
-      return true if v.is_a?(String) && v =~ /^[a-z0-9]+$/
+    def wf_integration_id?(id)
+      return true if id.is_a?(String) && id =~ /^[a-z0-9]+$/
       raise Wavefront::Exception::InvalidIntegrationId
     end
   end
+  # rubocop:enable Metrics/ModuleLength
 end