Class: Wavefront::Base

Inherits:
Object
  • Object
show all
Includes:
Mixins, Validators
Defined in:
lib/wavefront-sdk/base.rb

Overview

Abstract class from which all API classes inherit. When you make any call to the Wavefront API from this SDK, you are returned an OpenStruct object.

Returns:

  • a Wavefront::Response object

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Mixins

#parse_time

Methods included from Validators

#wf_alert_id?, #wf_alert_severity?, #wf_cloudintegration_id?, #wf_dashboard_id?, #wf_epoch?, #wf_event_id?, #wf_granularity?, #wf_link_id?, #wf_link_template?, #wf_maintenance_window_id?, #wf_message_id?, #wf_metric_name?, #wf_ms_ts?, #wf_name?, #wf_point?, #wf_point_tags?, #wf_proxy_id?, #wf_savedsearch_entity?, #wf_savedsearch_id?, #wf_source_id?, #wf_string?, #wf_tag?, #wf_ts?, #wf_user_id?, #wf_value?, #wf_version?, #wf_webhook_id?

Constructor Details

#initialize(creds = {}, opts = {}) ⇒ Nil

Create a new API object. This will always be called from a class which inherits this one. If the inheriting class defines #post_initialize, that method will be called afterwards, with the same arguments.

Parameters:

  • creds (Hash) (defaults to: {}) —

    must contain the keys ‘endpoint` (the Wavefront API server) and `token`, the user token with which you wish to access the endpoint. Can optionally contain `agent`, which will become the `user-agent` string sent with all requests.

  • opts (Hash) (defaults to: {}) —

    options governing class behaviour. Expected keys are ‘debug`, `noop` and `verbose`, all boolean; and `logger`, which must be a standard Ruby logger object. You can also pass :response_only. If this is true, you will only be returned a hash of the ’response’ object returned by Wavefront.



45
46
47
48
49
50
51
52
53
54
 
# File 'lib/wavefront-sdk/base.rb', line 45

def initialize(creds = {}, opts = {})
  @opts  = opts
  @debug = opts[:debug] || false
  @noop = opts[:noop] || false
  @verbose = opts[:verbose] || false
  @logger = opts[:logger] || nil
  setup_endpoint(creds)

  post_initialize(creds, opts) if respond_to?(:post_initialize)
end

Instance Attribute Details

#api_base ⇒ String (readonly)

Derive the first part of the API path from the class name. You can override this in your class if you wish

Returns:

  • (String) —

    portion of API URI



74
75
76
 
# File 'lib/wavefront-sdk/base.rb', line 74

def api_base
  @api_base
end

#conn ⇒ Object (readonly)

Returns the value of attribute conn.



24
25
26
 
# File 'lib/wavefront-sdk/base.rb', line 24

def conn
  @conn
end

#debug ⇒ Object (readonly)

Returns the value of attribute debug.



24
25
26
 
# File 'lib/wavefront-sdk/base.rb', line 24

def debug
  @debug
end

#logger ⇒ Object (readonly)

Returns the value of attribute logger.



24
25
26
 
# File 'lib/wavefront-sdk/base.rb', line 24

def logger
  @logger
end

#net ⇒ Object (readonly)

Returns the value of attribute net.



24
25
26
 
# File 'lib/wavefront-sdk/base.rb', line 24

def net
  @net
end

#noop ⇒ Object (readonly)

Returns the value of attribute noop.



24
25
26
 
# File 'lib/wavefront-sdk/base.rb', line 24

def noop
  @noop
end

#opts ⇒ Object (readonly)

Returns the value of attribute opts.



24
25
26
 
# File 'lib/wavefront-sdk/base.rb', line 24

def opts
  @opts
end

#update_keys ⇒ Object (readonly)

Returns the value of attribute update_keys.



24
25
26
 
# File 'lib/wavefront-sdk/base.rb', line 24

def update_keys
  @update_keys
end

#verbose ⇒ Object (readonly)

Returns the value of attribute verbose.



24
25
26
 
# File 'lib/wavefront-sdk/base.rb', line 24

def verbose
  @verbose
end

Instance Method Details

#api_delete(path) ⇒ Hash

Make a DELETE call to the Wavefront API and return the result as a Ruby hash. Can optionally perform a verbose noop, if the #noop class variable is set. If #verbose is set, then prints the information used to build the URI.

Parameters:

  • path (String) —

    path to be appended to the #net path.

Returns:

  • (Hash) —

    API response



153
154
155
 
# File 'lib/wavefront-sdk/base.rb', line 153

def api_delete(path)
  make_call(mk_conn(path), :delete)
end

#api_get(path, query = {}) ⇒ Hash

Make a GET call to the Wavefront API and return the result as a Ruby hash. Can optionally perform a verbose noop, if the #noop class variable is set. If #verbose is set, then prints the information used to build the URI.

Parameters:

  • path (String) —

    path to be appended to the #net path.

  • query (Hash) (defaults to: {}) —

    optional key-value pairs with will be made into aquery string

Returns:

  • (Hash) —

    API response



105
106
107
 
# File 'lib/wavefront-sdk/base.rb', line 105

def api_get(path, query = {})
  make_call(mk_conn(path), :get, nil, query)
end

#api_post(path, body = nil, ctype = 'text/plain') ⇒ Hash

Make a POST call to the Wavefront API and return the result as a Ruby hash. Can optionally perform a verbose noop, if the #noop class variable is set. If #verbose is set, then prints the information used to build the URI.

Parameters:

  • path (String) —

    path to be appended to the #net path.

  • body (String) (defaults to: nil) —

    optional body text to post

  • ctype (String) (defaults to: 'text/plain') —

    the content type to use when posting

Returns:

  • (Hash) —

    API response



120
121
122
123
124
125
 
# File 'lib/wavefront-sdk/base.rb', line 120

def api_post(path, body = nil, ctype = 'text/plain')
  body = body.to_json unless body.is_a?(String)
  make_call(mk_conn(path, { 'Content-Type': ctype,
                                   'Accept': 'application/json'}),
            :post, nil, body)
end

#api_put(path, body = nil, ctype = 'application/json') ⇒ Hash

Make a PUT call to the Wavefront API and return the result as a Ruby hash. Can optionally perform a verbose noop, if the #noop class variable is set. If #verbose is set, then prints the information used to build the URI.

Parameters:

  • path (String) —

    path to be appended to the #net path.

  • body (String) (defaults to: nil) —

    optional body text to post

  • ctype (String) (defaults to: 'application/json') —

    the content type to use when putting

Returns:

  • (Hash) —

    API response



138
139
140
141
142
 
# File 'lib/wavefront-sdk/base.rb', line 138

def api_put(path, body = nil, ctype = 'application/json')
  make_call(mk_conn(path, { 'Content-Type': ctype,
                                  'Accept': 'application/json' }),
            :put, nil, body.to_json)
end

#hash_for_update(old, new) ⇒ Hash

doing a PUT to update an object requires only a certain subset of the keys returned by #describe(). This method takes the existing description of an object and turns it into a new has which can be PUT.

Parameters:

  • old (Hash) —

    a hash of the existing object

  • new (Hash) —

    the keys you wish to update

Returns:

  • (Hash) —

    a hash containing only the keys which need to be sent to the API. Keys will be symbolized.

Raises:

  • (ArgumentError) 


167
168
169
170
171
172
173
 
# File 'lib/wavefront-sdk/base.rb', line 167

def hash_for_update(old, new)
  raise ArgumentError unless old.is_a?(Hash) && new.is_a?(Hash)

  Hash[old.merge(new).map { |k, v| [k.to_sym, v] }].select do |k, _v|
    update_keys.include?(k)
  end
end

#log(msg, level = nil) ⇒ Object

Send a message to a Ruby logger object if the user supplied one, or print to standard out if not.

Parameters:

  • msg (String) —

    the string to print

  • level (Symbol) (defaults to: nil) —

    the level of the message. :verbose messages equate to a standard INFO log level and :debug to DEBUG.



183
184
185
186
187
188
189
190
191
192
193
194
 
# File 'lib/wavefront-sdk/base.rb', line 183

def log(msg, level = nil)

  if logger
    logger.send(level || :info, msg)
  else
    # print it unless it's a debug and we're not in debug
    #
    return if level == :debug && ! opts[:debug]
    return if level == :info && ! opts[:verbose]
    puts msg
  end
end

#mk_conn(path, headers = {}) ⇒ URI::HTTPS

Create a Faraday connection object. The server comes from the endpoint passed to the initializer in the ‘creds’ hash; the root of the URI is dynamically derived by the #setup_endpoint method.

Parameters:

  • headers (Hash) (defaults to: {}) —

    additional headers

Returns:

  • (URI::HTTPS) 


86
87
88
89
90
91
92
 
# File 'lib/wavefront-sdk/base.rb', line 86

def mk_conn(path, headers = {})
  Faraday.new(
    url:     Addressable::URI.encode("https://#{net[:endpoint]}" +
             [net[:api_base], path].uri_concat),
    headers: net[:headers].merge(headers)
  )
end

#respond(resp) ⇒ Object

If we need to massage a raw response to fit what the Wavefront::Response class expects (I’m looking at you, ‘User’), a class can provide a #response_shim method.



200
201
202
203
204
205
206
 
# File 'lib/wavefront-sdk/base.rb', line 200

def respond(resp)
  body = respond_to?(:response_shim) ? response_shim(resp.body,
                                                     resp.status) :
                                       resp.body

  Wavefront::Response.new(body, resp.status)
end

#time_to_ms(t) ⇒ Ingeter

Convert an epoch timestamp into epoch milliseconds. If the timestamp looks like it’s already epoch milliseconds, return it as-is.

Parameters:

  • t (Integer) —

    epoch timestamp

Returns:

  • (Ingeter) —

    epoch millisecond timestamp



63
64
65
66
67
 
# File 'lib/wavefront-sdk/base.rb', line 63

def time_to_ms(t)
  return false unless t.is_a?(Integer)
  return t if t.to_s.size == 13
  (t.to_f * 1000).round
end