Class: Librato::Metrics::Client

Inherits:
Object
  • Object
show all
Extended by:
Forwardable
Defined in:
lib/librato/metrics/client.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#api_keyObject

Returns the value of attribute api_key


9
10
11
# File 'lib/librato/metrics/client.rb', line 9

def api_key
  @api_key
end

#emailObject

Returns the value of attribute email


9
10
11
# File 'lib/librato/metrics/client.rb', line 9

def email
  @email
end

#proxyObject

Returns the value of attribute proxy


9
10
11
# File 'lib/librato/metrics/client.rb', line 9

def proxy
  @proxy
end

Instance Method Details

#agent_identifier(*args) ⇒ Object

Provide agent identifier for the developer program. See: support.metrics.librato.com/knowledgebase/articles/53548-developer-program

Examples:

Have the gem build your identifier string

Librato::Metrics.agent_identifier 'flintstone', '0.5', 'fred'

Provide your own identifier string

Librato::Metrics.agent_identifier 'flintstone/0.5 (dev_id:fred)'

Remove identifier string

Librato::Metrics.agent_identifier ''

22
23
24
25
26
27
28
29
30
31
# File 'lib/librato/metrics/client.rb', line 22

def agent_identifier(*args)
  if args.length == 1
    @agent_identifier = args.first
  elsif args.length == 3
    @agent_identifier = "#{args[0]}/#{args[1]} (dev_id:#{args[2]})"
  elsif ![0,1,3].include?(args.length)
    raise ArgumentError, 'invalid arguments, see method documentation'
  end
  @agent_identifier ||= ''
end

#annotatorObject


33
34
35
# File 'lib/librato/metrics/client.rb', line 33

def annotator
  @annotator ||= Annotator.new(client: self)
end

#api_endpointString

API endpoint to use for queries and direct persistence.

Returns:

  • (String)

    api_endpoint


41
42
43
# File 'lib/librato/metrics/client.rb', line 41

def api_endpoint
  @api_endpoint ||= 'https://metrics-api.librato.com'
end

#api_endpoint=(endpoint) ⇒ Object

Set API endpoint for use with queries and direct persistence. Generally you should not need to set this as it will default to the current Librato Metrics endpoint.


50
51
52
# File 'lib/librato/metrics/client.rb', line 50

def api_endpoint=(endpoint)
  @api_endpoint = endpoint
end

#authenticate(email, api_key) ⇒ Object

Authenticate for direct persistence

Parameters:

  • email (String)
  • api_key (String)

58
59
60
61
# File 'lib/librato/metrics/client.rb', line 58

def authenticate(email, api_key)
  flush_authentication
  self.email, self.api_key = email, api_key
end

#connectionObject

Current connection object

Raises:


65
66
67
68
69
70
# File 'lib/librato/metrics/client.rb', line 65

def connection
  # prevent successful creation if no credentials set
  raise CredentialsMissing unless (self.email and self.api_key)
  @connection ||= Connection.new(client: self, api_endpoint: api_endpoint,
                                 adapter: faraday_adapter, proxy: self.proxy)
end

#create_snapshot(options = {}) ⇒ Object

Create a snapshot of an instrument

Examples:

Take a snapshot of the instrument at metrics-api.librato.com/v1/instruments/42 using a

duration of 3 hours and ending at now.
Librato::Metrics.snapshot(subject: {instrument: {href: "https://metrics-api.librato.com/v1/instruments/42"}},
                          duration: 3.hours, end_time: Time.now)

Parameters:

  • Hash

    options Params for the snapshot


393
394
395
396
397
398
399
400
# File 'lib/librato/metrics/client.rb', line 393

def create_snapshot(options = {})
  url = "snapshots"
  response = connection.post do |request|
    request.url connection.build_url(url)
    request.body = SmartJSON.write(options)
  end
  parsed = SmartJSON.read(response.body)
end

#custom_user_agentObject


81
82
83
# File 'lib/librato/metrics/client.rb', line 81

def custom_user_agent
  @user_agent
end

#custom_user_agent=(agent) ⇒ Object

Overrride user agent for this client's connections. If you are trying to specify an agent identifier for developer program, see #agent_identifier.


76
77
78
79
# File 'lib/librato/metrics/client.rb', line 76

def custom_user_agent=(agent)
  @user_agent = agent
  @connection = nil
end

#delete_metrics(*metric_names) ⇒ Object

Completely delete metrics with the given names. Be careful with this, this is instant and permanent.

Examples:

Delete metric 'temperature'

Librato::Metrics.delete_metrics :temperature

Delete metrics 'foo' and 'bar'

Librato::Metrics.delete_metrics :foo, :bar

Delete metrics that start with 'foo' except 'foobar'

Librato::Metrics.delete_metrics names: 'foo*', exclude: ['foobar']

Raises:


97
98
99
100
101
102
103
104
105
106
107
108
109
110
# File 'lib/librato/metrics/client.rb', line 97

def delete_metrics(*metric_names)
  raise(NoMetricsProvided, 'Metric name missing.') if metric_names.empty?
  if metric_names[0].respond_to?(:keys) # hash form
    params = metric_names[0]
  else
    params = { names: metric_names.map(&:to_s) }
  end
  connection.delete do |request|
    request.url connection.build_url("metrics")
    request.body = SmartJSON.write(params)
  end
  # expects 204, middleware will raise exception otherwise.
  true
end

#faraday_adapterObject

Return current adapter this client will use. Defaults to Metrics.faraday_adapter if set, otherwise Faraday.default_adapter


115
116
117
# File 'lib/librato/metrics/client.rb', line 115

def faraday_adapter
  @faraday_adapter ||= default_faraday_adapter
end

#faraday_adapter=(adapter) ⇒ Object

Set faraday adapter this client will use


120
121
122
# File 'lib/librato/metrics/client.rb', line 120

def faraday_adapter=(adapter)
  @faraday_adapter = adapter
end

#flush_authenticationObject

Purge current credentials and connection.


248
249
250
251
252
# File 'lib/librato/metrics/client.rb', line 248

def flush_authentication
  self.email = nil
  self.api_key = nil
  @connection = nil
end

#get_composite(definition, options = {}) ⇒ Object

Retrieve measurements for a given composite metric definition. :start_time and :resolution are required options, :end_time is optional.

Examples:

Get 5m moving average of 'foo'

measurements = Librato::Metrics.get_composite
  'moving_average(mean(series("foo", "*"), {size: "5"}))',
  start_time: Time.now.to_i - 60*60, resolution: 300

Parameters:

  • definition (String)

    Composite definition

  • options (hash) (defaults to: {})

    Query options


135
136
137
138
139
140
141
142
143
144
145
146
# File 'lib/librato/metrics/client.rb', line 135

def get_composite(definition, options={})
  unless options[:start_time] && options[:resolution]
    raise "You must provide a :start_time and :resolution"
  end
  query = options.dup
  query[:compose] = definition
  url = connection.build_url("metrics", query)
  response = connection.get(url)
  parsed = SmartJSON.read(response.body)
  # TODO: pagination support
  parsed
end

#get_measurements(metric_name, options = {}) ⇒ Object

Retrieve data points for a specific metric

A full list of query parameters can be found in the API documentation: http://dev.librato.com/v1/get/metrics/:name

Examples:

Get 20 most recent data points for metric

data = Librato::Metrics.get_measurements :temperature, count: 20

Get 20 most recent data points for a specific source

data = Librato::Metrics.get_measurements :temperature, count: 20,
                                         source: 'app1'

Get the 20 most recent 15 minute data point rollups

data = Librato::Metrics.get_measurements :temperature, count: 20,
                                         resolution: 900

Get data points for the last hour

data = Librato::Metrics.get_measurements start_time: Time.now-3600

Get 15 min data points from two hours to an hour ago

data = Librato::Metrics.get_measurements start_time: Time.now-7200,
                                         end_time: Time.now-3600,
                                         resolution: 900

Parameters:

  • metric_name (Symbol|String)

    Metric name

  • options (Hash) (defaults to: {})

    Query options

Raises:

  • (ArgumentError)

241
242
243
244
# File 'lib/librato/metrics/client.rb', line 241

def get_measurements(metric_name, options = {})
  raise ArgumentError, "you must provide at least a :start_time or :count" if options.empty?
  get_metric(metric_name, options)["measurements"]
end

#get_metric(name, options = {}) ⇒ Object

Retrieve a specific metric by name, optionally including data points

A full list of query parameters can be found in the API documentation: http://dev.librato.com/v1/get/metrics/:name

Examples:

Get attributes for a metric

metric = Librato::Metrics.get_metric :temperature

Get a metric and its 20 most recent data points

metric = Librato::Metrics.get_metric :temperature, count: 20
metric['measurements'] # => {...}

Parameters:

  • name (Symbol|String)

    Metric name

  • options (Hash) (defaults to: {})

    Query options


162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
# File 'lib/librato/metrics/client.rb', line 162

def get_metric(name, options = {})
  query = options.dup
  if query[:start_time].respond_to?(:year)
    query[:start_time] = query[:start_time].to_i
  end
  if query[:end_time].respond_to?(:year)
    query[:end_time] = query[:end_time].to_i
  end
  unless query.empty?
    query[:resolution] ||= 1
  end
  # expects 200
  url = connection.build_url("metrics/#{name}", query)
  response = connection.get(url)
  parsed = SmartJSON.read(response.body)
  # TODO: pagination support
  parsed
end

#get_series(metric_name, options = {}) ⇒ Object

Retrieve series of measurements for a given metric

Examples:

Get series for metric

series = Librato::Metrics.get_series :requests, resolution: 1, duration: 3600

Get series for metric grouped by tag

query = { duration: 3600, resolution: 1, group_by: "environment", group_by_function: "sum" }
series = Librato::Metrics.get_series :requests, query

Get series for metric grouped by tag and negated by tag filter

query = { duration: 3600, resolution: 1, group_by: "environment", group_by_function: "sum", tags_search: "environment=!staging" }
series = Librato::Metrics.get_series :requests, query

Parameters:

  • metric_name (Symbol|String)

    Metric name

  • options (Hash) (defaults to: {})

    Query options

Raises:

  • (ArgumentError)

196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
# File 'lib/librato/metrics/client.rb', line 196

def get_series(metric_name, options={})
  raise ArgumentError, ":resolution and :duration or :start_time must be set" if options.empty?
  query = options.dup
  if query[:start_time].respond_to?(:year)
    query[:start_time] = query[:start_time].to_i
  end
  if query[:end_time].respond_to?(:year)
    query[:end_time] = query[:end_time].to_i
  end
  query[:resolution] ||= 1
  unless query[:start_time] || query[:end_time]
    query[:duration] ||= 3600
  end
  url = connection.build_url("measurements/#{metric_name}", query)
  response = connection.get(url)
  parsed = SmartJSON.read(response.body)
  parsed["series"]
end

#get_snapshot(id) ⇒ Object

Retrive a snapshot, to check its progress or find its image_href

Examples:

Get a snapshot identified by 42

Librato::Metrics.get_snapshot 42

Parameters:

  • id (Integer|String)

408
409
410
411
412
# File 'lib/librato/metrics/client.rb', line 408

def get_snapshot(id)
  url = "snapshots/#{id}"
  response = connection.get(url)
  parsed = SmartJSON.read(response.body)
end

#get_source(name) ⇒ Object

Retrieve a single source by name. See dev.librato.com/v1/get/sources/:name

Examples:

Get the source for a particular EC2 instance from Cloudwatch

Librato::Metrics.get_source "us-east-1b.i-f1bc8c9c"

Parameters:

  • String

    name


361
362
363
364
365
# File 'lib/librato/metrics/client.rb', line 361

def get_source(name)
  url = connection.build_url("sources/#{name}")
  response = connection.get(url)
  parsed = SmartJSON.read(response.body)
end

#metrics(options = {}) ⇒ Object

List currently existing metrics

Examples:

List all metrics

Librato::Metrics.metrics

List metrics with 'foo' in the name

Librato::Metrics.metrics name: 'foo'

Parameters:

  • options (Hash) (defaults to: {})

263
264
265
266
267
268
269
# File 'lib/librato/metrics/client.rb', line 263

def metrics(options={})
  query = {}
  query[:name] = options[:name] if options[:name]
  offset = 0
  path = "metrics"
  Collection.paginated_metrics(connection, path, query)
end

#new_queue(options = {}) ⇒ Queue

Create a new queue which uses this client.

Returns:


274
275
276
277
# File 'lib/librato/metrics/client.rb', line 274

def new_queue(options={})
  options[:client] = self
  Queue.new(options)
end

#persistenceSymbol

Persistence type to use when saving metrics. Default is :direct.

Returns:

  • (Symbol)

283
284
285
# File 'lib/librato/metrics/client.rb', line 283

def persistence
  @persistence ||= :direct
end

#persistence=(persist_method) ⇒ Object

Set persistence type to use when saving metrics.

Parameters:

  • persist_method (Symbol)

290
291
292
# File 'lib/librato/metrics/client.rb', line 290

def persistence=(persist_method)
  @persistence = persist_method
end

#persisterObject

Current persister object.


295
296
297
# File 'lib/librato/metrics/client.rb', line 295

def persister
  @queue ? @queue.persister : nil
end

#sources(filter = {}) ⇒ Object

List sources, optionally limited by a name. See dev.librato.com/v1/sources and dev.librato.com/v1/get/sources

Examples:

Get sources matching “production”

Librato::Metrics.sources name: "production"

Parameters:

  • filter (Hash) (defaults to: {})

348
349
350
351
352
353
# File 'lib/librato/metrics/client.rb', line 348

def sources(filter = {})
  query = {}
  query[:name] = filter[:name] if filter.has_key?(:name)
  path = "sources"
  Collection.paginated_collection("sources", connection, path, query)
end

#submit(args) ⇒ Object

Submit all queued metrics.


301
302
303
304
305
306
307
# File 'lib/librato/metrics/client.rb', line 301

def submit(args)
  @queue ||= Queue.new(client: self,
                       skip_measurement_times: true,
                       clear_failures: true)
  @queue.add args
  @queue.submit
end

#update_metric(metric, options = {}) ⇒ Object

Update a single metric with new attributes.

Examples:

Update metric 'temperature'

Librato::Metrics.update_metric :temperature, period: 15, attributes: { color: 'F00' }

Update metric 'humidity', creating it if it doesn't exist

Librato::Metrics.update_metric 'humidity', type: :gauge, period: 60, display_name: 'Humidity'

317
318
319
320
321
322
323
# File 'lib/librato/metrics/client.rb', line 317

def update_metric(metric, options = {})
  url = "metrics/#{metric}"
  connection.put do |request|
    request.url connection.build_url(url)
    request.body = SmartJSON.write(options)
  end
end

#update_metrics(metrics) ⇒ Object

Update multiple metrics.

Examples:

Update multiple metrics by name

Librato::Metrics.update_metrics names: ["foo", "bar"], period: 60

Update all metrics that start with 'foo' that aren't 'foobar'

Librato::Metrics.update_metrics names: 'foo*', exclude: ['foobar'], display_min: 0

333
334
335
336
337
338
339
# File 'lib/librato/metrics/client.rb', line 333

def update_metrics(metrics)
  url = "metrics" # update multiple metrics
  connection.put do |request|
    request.url connection.build_url(url)
    request.body = SmartJSON.write(metrics)
  end
end

#update_source(name, options = {}) ⇒ Object

Update a source by name. See dev.librato.com/v1/get/sources/:name

Examples:

Update the source display name for a particular EC2 instance from Cloudwatch

Librato::Metrics.update_source "us-east-1b.i-f1bc8c9c", display_name: "Production Web 1"

Parameters:

  • String

    name

  • Hash

    options


374
375
376
377
378
379
380
# File 'lib/librato/metrics/client.rb', line 374

def update_source(name, options = {})
  url = "sources/#{name}"
  connection.put do |request|
    request.url connection.build_url(url)
    request.body = SmartJSON.write(options)
  end
end